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

# Run a Composition

> Runs a query on a single composition and returns matching results.

**Required ACL:** `search`


## OpenAPI

````yaml specs/composition.yml post /1/compositions/{compositionID}/run
openapi: 3.1.0
info:
  title: Composition API
  summary: >-
    The Algolia Composition API lets you run composed search requests on your
    Compositions
  description: >
    ## Client libraries


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


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


    ## Base URLs


    Base URLs for the Composition 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 in the request body for POST and PUT requests.


    ## Response status and errors


    The Composition 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 Composition 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: Advanced endpoints to manage tasks.
  - name: Composition Rules
    description: Manage your compositions rules.
  - name: Compositions
    description: Manage your compositions and composition settings.
  - name: Search
    description: Search one or more indices for matching records or facet values.
paths:
  /1/compositions/{compositionID}/run:
    post:
      tags:
        - Search
      summary: Run a Composition
      description: Runs a query on a single composition and returns matching results.
      operationId: search
      parameters:
        - $ref: '#/components/parameters/compositionID'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              title: requestBody
              type: object
              additionalProperties: false
              properties:
                feedsOrder:
                  $ref: '#/components/schemas/feedsOrder'
                params:
                  $ref: '#/components/schemas/params'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/searchResponse'
        '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 CompositionClient(
              new CompositionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
            );

            // Call the API
            var response = await client.SearchAsync<Hit>(
              "foo",
              new RequestBody
              {
                Params = new Params { Query = "batman" },
                FeedsOrder = new List<string> { "feed-movies", "feed-comics" },
              }
            );

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

            // Call the API
            final response = await client.search(
              compositionID: "foo",
              requestBody: RequestBody(
                params: Params(
                  query: "batman",
                ),
                feedsOrder: [
                  "feed-movies",
                  "feed-comics",
                ],
              ),
            );

            // print the response
            print(response);
        - lang: go
          label: Go
          source: >-
            // Initialize the client

            client, err := composition.NewClient("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY")

            if err != nil {
              // The client can fail to initialize if you pass an invalid parameter.
              panic(err)
            }


            // Call the API

            response, err := client.Search(client.NewApiSearchRequest(
              "foo",
              composition.NewEmptyRequestBody().SetParams(
                composition.NewEmptyParams().SetQuery("batman")).SetFeedsOrder(
                []string{"feed-movies", "feed-comics"})))
            if err != nil {
              // handle the eventual error
              panic(err)
            }



            // print the response

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

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


            // Call the API

            SearchResponse response = client.search(
              "foo",
              new RequestBody().setParams(new Params().setQuery("batman")).setFeedsOrder(Arrays.asList("feed-movies", "feed-comics")),
              Hit.class
            );


            // print the response

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

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


            // Call the API

            const response = await client.search({
              compositionID: 'foo',
              requestBody: { params: { query: 'batman' }, feedsOrder: ['feed-movies', 'feed-comics'] },
            });



            // print the response

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

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


            // Call the API

            var response =
              client.search(
                compositionID = "foo",
                requestBody =
                  RequestBody(
                    params = Params(query = "batman"),
                    feedsOrder = listOf("feed-movies", "feed-comics"),
                  ),
              )


            // print the response

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

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


            // Call the API

            $response = $client->search(
                'foo',
                ['params' => ['query' => 'batman',
                ],
                    'feedsOrder' => [
                        'feed-movies',

                        'feed-comics',
                    ],
                ],
            );



            // print the response

            var_dump($response);
        - lang: python
          label: Python
          source: >-
            # Initialize the client

            # In an asynchronous context, you can use CompositionClient instead,
            which exposes the exact same methods.

            client = CompositionClientSync("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY")


            # Call the API

            response = client.search(
                composition_id="foo",
                request_body={
                    "params": {
                        "query": "batman",
                    },
                    "feedsOrder": [
                        "feed-movies",
                        "feed-comics",
                    ],
                },
            )



            # print the response

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

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


            # Call the API

            response = client.search(
              "foo",
              Algolia::Composition::RequestBody.new(
                params: Algolia::Composition::Params.new(query: "batman"),
                feeds_order: ["feed-movies", "feed-comics"]
              )
            )



            # print the response

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

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


            // Call the API

            val response = Await.result(
              client.search(
                compositionID = "foo",
                requestBody = RequestBody(
                  params = Some(
                    Params(
                      query = Some("batman")
                    )
                  ),
                  feedsOrder = Some(Seq("feed-movies", "feed-comics"))
                )
              ),
              Duration(100, "sec")
            )


            // print the response

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

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


            // Call the API

            let response: CompositionSearchResponse<CompositionHit> = try await
            client.search(
                compositionID: "foo",
                requestBody: RequestBody(
                    params: CompositionParams(query: "batman"),
                    feedsOrder: ["feed-movies", "feed-comics"]
                )
            )


            // print the response

            print(response)
        - lang: cURL
          label: curl
          source: |-
            curl --request POST \
              --url https://algolia_application_id.algolia.net/1/compositions/my_composition_object_id/run \
              --header 'accept: application/json' \
              --header 'content-type: application/json' \
              --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
              --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID' \
              --data '
            {
              "params": {
                "analytics": true,
                "analyticsTags": [],
                "aroundLatLng": "40.71,-74.01",
                "aroundLatLngViaIP": false,
                "aroundRadius": 1,
                "aroundPrecision": 10,
                "clickAnalytics": false,
                "enableABTest": true,
                "enablePersonalization": false,
                "enableReRanking": true,
                "enableRules": true,
                "facetFilters": [
                  [
                    "category:Book",
                    "category:-Movie"
                  ],
                  "author:John Doe"
                ],
                "facets": [
                  "category",
                  "disjunctive(brand)",
                  "price"
                ],
                "filters": "(category:Book OR category:Ebook) AND _tags:published",
                "getRankingInfo": false,
                "hitsPerPage": 20,
                "injectedItems": {
                  "my-group-key": {
                    "items": [
                      {
                        "objectID": "my-object-1",
                        "metadata": {
                          "my-field": "my-value"
                        }
                      },
                      {
                        "objectID": "my-object-2",
                        "metadata": {
                          "my-field": "my-value-2"
                        }
                      }
                    ]
                  },
                  "my-other-group-key": {
                    "items": [
                      {
                        "objectID": "my-other-object-1"
                      },
                      {
                        "objectID": "my-other-object-2"
                      }
                    ]
                  }
                },
                "insideBoundingBox": "lorem",
                "insidePolygon": [
                  [
                    47.3165,
                    4.9665,
                    47.3424,
                    5.0201,
                    47.32,
                    4.9
                  ],
                  [
                    40.9234,
                    2.1185,
                    38.643,
                    1.9916,
                    39.2587,
                    2.0104
                  ]
                ],
                "minimumAroundRadius": 1,
                "naturalLanguages": [],
                "numericFilters": [
                  [
                    "inStock = 1",
                    "deliveryDate < 1441755506"
                  ],
                  "price < 1000"
                ],
                "optionalFilters": [
                  "category:Book",
                  "author:John Doe"
                ],
                "page": 0,
                "query": "",
                "queryLanguages": [
                  "es"
                ],
                "relevancyStrictness": 90,
                "ruleContexts": [
                  "mobile"
                ],
                "sortBy": "Price (asc)",
                "userToken": "test-user-123"
              },
              "feedsOrder": [
                "feed-1",
                "feed-3"
              ]
            }
            '
components:
  parameters:
    compositionID:
      in: path
      name: compositionID
      description: Unique Composition ObjectID.
      required: true
      schema:
        $ref: '#/components/schemas/compositionObjectID'
  schemas:
    feedsOrder:
      type: array
      description: >
        A list of Feed IDs that specifies the order in which to order the
        results in the response. 

        The IDs should be a subset of those in the `feeds` object of the
        targeted `multifeed` Composition / Composition Rule, and only those
        specified will be processed. 


        The value overrides the value in the defined behavior, and when
        unspecified, the value defined in the behavior is used. When neither
        value is present, all feeds are processed.
      items:
        type: string
      default: null
      example:
        - feed-1
        - feed-3
    params:
      title: Run composition parameters as object
      type: object
      additionalProperties: false
      properties:
        analytics:
          $ref: '#/components/schemas/analytics'
        analyticsTags:
          $ref: '#/components/schemas/analyticsTags'
        aroundLatLng:
          $ref: '#/components/schemas/aroundLatLng'
        aroundLatLngViaIP:
          $ref: '#/components/schemas/aroundLatLngViaIP'
        aroundPrecision:
          $ref: '#/components/schemas/aroundPrecision'
        aroundRadius:
          $ref: '#/components/schemas/aroundRadius'
        clickAnalytics:
          $ref: '#/components/schemas/clickAnalytics'
        enableABTest:
          $ref: '#/components/schemas/enableABTest'
        enablePersonalization:
          $ref: '#/components/schemas/enablePersonalization'
        enableReRanking:
          $ref: '#/components/schemas/enableReRanking'
        enableRules:
          $ref: '#/components/schemas/enableRules'
        facetFilters:
          $ref: '#/components/schemas/facetFilters'
        facets:
          $ref: '#/components/schemas/facets'
        filters:
          $ref: '#/components/schemas/filters'
        getRankingInfo:
          $ref: '#/components/schemas/getRankingInfo'
        hitsPerPage:
          $ref: '#/components/schemas/hitsPerPage'
        injectedItems:
          $ref: '#/components/schemas/injectedItems'
        insideBoundingBox:
          $ref: '#/components/schemas/insideBoundingBox'
        insidePolygon:
          $ref: '#/components/schemas/insidePolygon'
        minimumAroundRadius:
          $ref: '#/components/schemas/minimumAroundRadius'
        naturalLanguages:
          $ref: '#/components/schemas/naturalLanguages'
        numericFilters:
          $ref: '#/components/schemas/numericFilters'
        optionalFilters:
          $ref: '#/components/schemas/optionalFilters'
        page:
          $ref: '#/components/schemas/page'
        query:
          $ref: '#/components/schemas/query'
        queryLanguages:
          $ref: '#/components/schemas/queryLanguages'
        relevancyStrictness:
          $ref: '#/components/schemas/relevancyStrictness'
        ruleContexts:
          $ref: '#/components/schemas/ruleContexts'
        sortBy:
          $ref: '#/components/schemas/sortBy'
        userToken:
          $ref: '#/components/schemas/userToken'
    searchResponse:
      additionalProperties: true
      allOf:
        - $ref: '#/components/schemas/compositionBaseSearchResponse'
        - $ref: '#/components/schemas/searchResults'
    compositionObjectID:
      type: string
      example: my_composition_object_id
      description: Composition unique identifier.
    analytics:
      type: boolean
      description: Whether this search will be included in Analytics.
      default: true
      x-categories:
        - Analytics
    analyticsTags:
      type: array
      items:
        type: string
      description: >-
        Tags to apply to the query for [segmenting analytics
        data](https://www.algolia.com/doc/guides/search-analytics/guides/segments).
      default: []
    aroundLatLng:
      type: string
      description: >
        Coordinates for the center of a circle, expressed as a comma-separated
        string of latitude and longitude.


        Only records included within a circle around this central location are
        included in the results.

        The radius of the circle is determined by the `aroundRadius` and
        `minimumAroundRadius` settings.

        This parameter is ignored if you also specify `insidePolygon` or
        `insideBoundingBox`.
      example: 40.71,-74.01
      default: ''
      x-categories:
        - Geo-Search
    aroundLatLngViaIP:
      type: boolean
      description: Whether to obtain the coordinates from the request's IP address.
      default: false
      x-categories:
        - Geo-Search
    aroundPrecision:
      description: >
        Precision of a coordinate-based search in meters to group results with
        similar distances.


        The Geo ranking criterion considers all matches within the same range of
        distances to be equal.
      oneOf:
        - type: integer
          default: 10
          description: >
            Distance in meters to group results by similar distances.


            For example, if you set `aroundPrecision` to 100, records wihin 100
            meters to the central coordinate are considered to have the same
            distance,

            as are records between 100 and 199 meters.
        - $ref: '#/components/schemas/aroundPrecisionFromValue'
      x-categories:
        - Geo-Search
    aroundRadius:
      description: >
        Maximum radius for a search around a central location.


        This parameter works in combination with the `aroundLatLng` and
        `aroundLatLngViaIP` parameters.

        By default, the search radius is determined automatically from the
        density of hits around the central location.

        The search radius is small if there are many hits close to the central
        coordinates.
      oneOf:
        - type: integer
          minimum: 1
          description: Maximum search radius around a central location in meters.
        - $ref: '#/components/schemas/aroundRadiusAll'
      x-categories:
        - Geo-Search
    clickAnalytics:
      type: boolean
      description: >
        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/doc/guides/sending-events/getting-started).
      default: false
      x-categories:
        - Analytics
    enableABTest:
      type: boolean
      description: |
        Whether to enable index level A/B testing for this run request.
        If the composition mixes multiple indices, the A/B test is ignored.
      default: true
      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 composition rules.
      default: true
      x-categories:
        - Composition Rules
    facetFilters:
      description: >
        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`.
      example:
        - - category:Book
          - category:-Movie
        - author:John Doe
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/facetFilters'
        - type: string
      x-categories:
        - Filtering
    facets:
      type: array
      items:
        type: string
      description: >
        Facets for which to retrieve facet values that match the search criteria
        and the number of matching facet values

        To retrieve all facets, use the wildcard character `*`.

        To retrieve disjunctive facets lists, annotate any facets with the
        `disjunctive` modifier.

        For more information, see
        [facets](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#contextual-facet-values-and-counts)
        and [disjunctive faceting for Smart
        Groups](https://www.algolia.com/doc/guides/managing-results/compositions/search-based-groups#facets-including-disjunctive-faceting).
      default: []
      example:
        - category
        - disjunctive(brand)
        - price
      examples:
        - - category
          - disjunctive(brand)
          - price
        - - '*'
        - - '*'
          - disjunctive(brand)
      x-categories:
        - Faceting
    filters:
      type: string
      description: >
        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 if the facet attribute name or facet value contains 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).
      example: (category:Book OR category:Ebook) AND _tags:published
      x-categories:
        - Filtering
    getRankingInfo:
      type: boolean
      description: Whether the run response should include detailed ranking information.
      default: false
      x-categories:
        - Advanced
    hitsPerPage:
      type: integer
      description: Number of hits per page.
      default: 20
      minimum: 1
      maximum: 1000
      x-categories:
        - Pagination
    injectedItems:
      type: object
      additionalProperties:
        $ref: '#/components/schemas/externalInjectedItem'
      description: >
        An object containing keys corresponding to the `key`s from an
        injection's `injectedItems` and values containing a list of hits to
        inject.
      default: {}
      x-categories:
        - Retail Media Network
      example:
        my-group-key:
          items:
            - objectID: my-object-1
              metadata:
                my-field: my-value
            - objectID: my-object-2
              metadata:
                my-field: my-value-2
        my-other-group-key:
          items:
            - objectID: my-other-object-1
            - objectID: my-other-object-2
    insideBoundingBox:
      oneOf:
        - type: string
        - type: 'null'
        - $ref: '#/components/schemas/insideBoundingBoxArray'
    insidePolygon:
      type: array
      items:
        type: array
        minItems: 6
        maxItems: 20000
        items:
          type: number
          format: double
      description: >
        Coordinates of a polygon in which to search.


        Polygons are defined by 3 to 10,000 points. Each point is represented by
        its latitude and longitude.

        Provide multiple polygons as nested arrays.

        For more information, see [filtering inside
        polygons](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas).

        This parameter is ignored if you also specify `insideBoundingBox`.
      example:
        - - 47.3165
          - 4.9665
          - 47.3424
          - 5.0201
          - 47.32
          - 4.9
        - - 40.9234
          - 2.1185
          - 38.643
          - 1.9916
          - 39.2587
          - 2.0104
      x-categories:
        - Geo-Search
    minimumAroundRadius:
      type: integer
      description: >-
        Minimum radius (in meters) for a search around a location when
        `aroundRadius` isn't set.
      minimum: 1
      x-categories:
        - Geo-Search
    naturalLanguages:
      type: array
      items:
        $ref: '#/components/schemas/supportedLanguage'
      description: >
        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`.
      default: []
      x-categories:
        - Languages
    numericFilters:
      description: >
        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`.
      example:
        - - inStock = 1
          - deliveryDate < 1441755506
        - price < 1000
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/numericFilters'
        - type: string
      x-categories:
        - Filtering
    optionalFilters:
      description: >
        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 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.

        - On virtual replicas, optional filters are applied _after_ the
        replica's [relevant
        sort](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/relevant-sort).
      example:
        - category:Book
        - author:John Doe
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/optionalFilters'
        - type: string
      x-categories:
        - Filtering
    page:
      type: integer
      description: Page of search results to retrieve.
      default: 0
      minimum: 0
      x-categories:
        - Pagination
    query:
      type: string
      description: Search query.
      default: ''
      x-categories:
        - Search
    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
    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
    ruleContexts:
      type: array
      items:
        type: string
      description: >
        Assigns a rule context to the run 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.
      default: []
      example:
        - mobile
      x-categories:
        - Composition Rules
    sortBy:
      type: string
      description: >
        Indicates which sorting strategy to apply for the request.

        The value must match one of the labels defined in the "sortingStrategy"
        mapping. For example, "Price (asc)", see Upsert Composition.

        At runtime, this label is used to look up the corresponding index or
        replica configured in "sortingStrategy", and the query is executed using
        that index instead of main's.


        In addition to "sortingStrategy", this parameter is also used to apply a
        matching Composition Rule that contains a condition defined to trigger
        on "sortBy", see Composition Rules.


        If no value is provided or an invalid value, no sorting strategy is
        applied.
      default: ''
      example: Price (asc)
    userToken:
      type: string
      description: >
        Unique pseudonymous or anonymous user identifier.


        This helps with analytics and click and conversion events.

        For more information, see [user
        token](https://www.algolia.com/doc/guides/sending-events/concepts/usertoken).
      example: test-user-123
      x-categories:
        - Personalization
    compositionBaseSearchResponse:
      type: object
      properties:
        compositions:
          $ref: '#/components/schemas/compositionsSearchResponse'
    searchResults:
      type: object
      additionalProperties: false
      properties:
        results:
          type: array
          description: Search results.
          items:
            $ref: '#/components/schemas/searchResultsItem'
      required:
        - results
    ErrorBase:
      description: Error.
      type: object
      x-keep-model: true
      additionalProperties: true
      properties:
        message:
          type: string
          example: Invalid Application-Id or API-Key
    aroundPrecisionFromValue:
      title: range objects
      type: array
      items:
        title: range
        type: object
        description: >-
          Range object with lower and upper values in meters to define custom
          ranges.
        properties:
          from:
            type: integer
            description: >-
              Lower boundary of a range in meters. The Geo ranking criterion
              considers all records within the range to be equal.
            example: 20
          value:
            type: integer
            description: >-
              Upper boundary of a range in meters. The Geo ranking criterion
              considers all records within the range to be equal.
    aroundRadiusAll:
      title: all
      type: string
      description: >-
        Return all records with a valid `_geoloc` attribute. Don't filter by
        distance.
      enum:
        - all
    externalInjectedItem:
      type: object
      description: |
        Contains a list of objects to inject from an external source.
      properties:
        items:
          type: array
          items:
            title: externalInjection
            type: object
            additionalProperties: false
            properties:
              objectID:
                type: string
                description: >-
                  An objectID injected from an external source and also present
                  in the targeted index.
              metadata:
                type: object
                additionalProperties: true
                description: >
                  User-defined key-values that will be added to the injected
                  item in the response.

                  This is identical to Hits metadata defined in Composition or
                  Composition Rule,

                  with the benefit of being set at runtime.
                example:
                  my-field: my-value
            required:
              - objectID
            example:
              objectID: my-object-1
              metadata':
                my-field: my-value
      required:
        - items
    insideBoundingBoxArray:
      type: array
      items:
        type: array
        minItems: 4
        maxItems: 4
        items:
          type: number
          format: double
      description: >
        Coordinates for a rectangular area in which to search.


        Each bounding box is defined by the two opposite points of its diagonal,
        and expressed as latitude and longitude pair:

        `[p1 lat, p1 long, p2 lat, p2 long]`.

        Provide multiple bounding boxes as nested arrays.

        For more information, see [rectangular
        area](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas).
      example:
        - - 47.3165
          - 4.9665
          - 47.3424
          - 5.0201
        - - 40.9234
          - 2.1185
          - 38.643
          - 1.9916
      x-categories:
        - Geo-Search
    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
    compositionsSearchResponse:
      type: object
      additionalProperties: true
      properties:
        run:
          type: array
          items:
            $ref: '#/components/schemas/compositionRunSearchResponse'
      required:
        - run
    searchResultsItem:
      allOf:
        - $ref: '#/components/schemas/baseSearchResponse'
        - $ref: '#/components/schemas/SearchFields'
        - $ref: '#/components/schemas/resultsCompositionsResponse'
    compositionRunSearchResponse:
      type: object
      additionalProperties: true
      properties:
        objectID:
          type: string
          description: The objectID of the composition which generated this result set.
        appliedRules:
          type: array
          items:
            $ref: '#/components/schemas/compositionRunAppliedRules'
      example:
        objectID: comp1765458818347
        appliedRules:
          - objectID: cr-1765458959657
      required:
        - objectID
    baseSearchResponse:
      type: object
      additionalProperties: true
      properties:
        _automaticInsights:
          type: boolean
          description: Whether automatic events collection is enabled for the application.
        abTestID:
          type: integer
          description: >-
            A/B test ID. This is only included in the response for indices that
            are part of an A/B test.
        abTestVariantID:
          type: integer
          minimum: 1
          description: >-
            Variant ID. This is only included in the response for indices that
            are part of an A/B test.
        appliedRules:
          description: Rules applied to the query.
          title: appliedRules
          type: array
          items:
            type: object
        aroundLatLng:
          type: string
          description: Computed geographical location.
          example: 40.71,-74.01
          pattern: ^(-?\d+(\.\d+)?),\s*(-?\d+(\.\d+)?)$
        automaticRadius:
          type: string
          description: Distance from a central coordinate provided by `aroundLatLng`.
        exhaustive:
          title: exhaustive
          type: object
          description: >-
            Whether certain properties of the search response are calculated
            exhaustive (exact) or approximated.
          properties:
            facetsCount:
              type: boolean
              title: facetsCount
              description: >-
                Whether the facet count is exhaustive (`true`) or approximate
                (`false`). See the [related
                discussion](https://support.algolia.com/hc/articles/4406975248145-Why-are-my-facet-and-hit-counts-not-accurate).
            facetValues:
              type: boolean
              title: facetValues
              description: The value is `false` if not all facet values are retrieved.
            nbHits:
              type: boolean
              title: nbHits
              description: >-
                Whether the `nbHits` is exhaustive (`true`) or approximate
                (`false`). When the query takes more than 50ms to be processed,
                the engine makes an approximation. This can happen when using
                complex filters on millions of records, when typo-tolerance was
                not exhaustive, or when enough hits have been retrieved (for
                example, after the engine finds 10,000 exact matches). `nbHits`
                is reported as non-exhaustive whenever an approximation is made,
                even if the approximation didn’t, in the end, impact the
                exhaustivity of the query.
            rulesMatch:
              type: boolean
              title: rulesMatch
              description: >-
                Rules matching exhaustivity. The value is `false` if rules were
                enable for this query, and could not be fully processed due a
                timeout. This is generally caused by the number of alternatives
                (such as typos) which is too large.
            typo:
              type: boolean
              title: typo
              description: >-
                Whether the typo search was exhaustive (`true`) or approximate
                (`false`). An approximation is done when the typo search query
                part takes more than 10% of the query budget (ie. 5ms by
                default) to be processed (this can happen when a lot of typo
                alternatives exist for the query). This field will not be
                included when typo-tolerance is entirely disabled.
        exhaustiveFacetsCount:
          type: boolean
          description: >-
            See the `facetsCount` field of the `exhaustive` object in the
            response.
          deprecated: true
        exhaustiveNbHits:
          type: boolean
          description: See the `nbHits` field of the `exhaustive` object in the response.
          deprecated: true
        exhaustiveTypo:
          type: boolean
          description: See the `typo` field of the `exhaustive` object in the response.
          deprecated: true
        facets:
          title: facets
          type: object
          additionalProperties:
            x-additionalPropertiesName: facet
            type: object
            additionalProperties:
              x-additionalPropertiesName: facet count
              type: integer
          description: Facet counts.
          example:
            category:
              food: 1
              tech: 42
        facets_stats:
          type: object
          description: Statistics for numerical facets.
          additionalProperties:
            title: facetStats
            type: object
            properties:
              avg:
                type: number
                format: double
                description: Average facet value in the results.
              max:
                type: number
                format: double
                description: Maximum value in the results.
              min:
                type: number
                format: double
                description: Minimum value in the results.
              sum:
                type: number
                format: double
                description: Sum of all values in the results.
        index:
          type: string
          example: indexName
          description: Index name used for the query.
        indexUsed:
          type: string
          description: >-
            Index name used for the query. During A/B testing, the targeted
            index isn't always the index used by the query.
          example: indexNameAlt
        message:
          type: string
          description: Warnings about the query.
        nbSortedHits:
          type: integer
          description: Number of hits selected and sorted by the relevant sort algorithm.
          example: 20
        parsedQuery:
          type: string
          description: >-
            Post-[normalization](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/#what-does-normalization-mean)
            query string that will be searched.
          example: george clo
        processingTimeMS:
          $ref: '#/components/schemas/processingTimeMS'
        processingTimingsMS:
          type: object
          description: >-
            Experimental. List of processing steps and their times, in
            milliseconds. You can use this list to investigate performance
            issues.
        queryAfterRemoval:
          type: string
          description: >-
            Markup text indicating which parts of the original query have been
            removed to retrieve a non-empty result set.
        queryID:
          type: string
          description: >-
            Unique identifier for the query. This is used for [click
            analytics](https://www.algolia.com/doc/guides/analytics/click-analytics).
          example: a00dbc80a8d13c4565a442e7e2dca80a
        redirect:
          title: redirect
          type: object
          description: >
            [Redirect results to a
            URL](https://www.algolia.com/doc/guides/managing-results/rules/merchandising-and-promoting/how-to/redirects),
            this this parameter is for internal use only.
          properties:
            index:
              type: array
              items:
                $ref: '#/components/schemas/RedirectRuleIndexMetadata'
        renderingContent:
          $ref: '#/components/schemas/renderingContent'
        serverTimeMS:
          type: integer
          description: Time the server took to process the request, in milliseconds.
          example: 20
        serverUsed:
          type: string
          description: Host name of the server that processed the request.
          example: c2-uk-3.algolia.net
        userData:
          $ref: '#/components/schemas/userData'
    SearchFields:
      type: object
      additionalProperties: false
      properties:
        hits:
          $ref: '#/components/schemas/hits'
        hitsPerPage:
          $ref: '#/components/schemas/SingleResultSet_hitsPerPage'
        nbHits:
          $ref: '#/components/schemas/nbHits'
        nbPages:
          $ref: '#/components/schemas/nbPages'
        page:
          $ref: '#/components/schemas/SingleResultSet_page'
        params:
          $ref: '#/components/schemas/SingleResultSet_params'
        query:
          $ref: '#/components/schemas/SingleResultSet_query'
    resultsCompositionsResponse:
      type: object
      properties:
        compositions:
          additionalProperties:
            $ref: '#/components/schemas/resultsCompositionInfoResponse'
        feedID:
          $ref: '#/components/schemas/feedID'
      required:
        - compositions
    compositionRunAppliedRules:
      type: object
      properties:
        objectID:
          type: string
          description: The objectID of the applied composition rule on this query.
      example:
        objectID: cr-1765458959657
      required:
        - objectID
    processingTimeMS:
      type: integer
      description: Time the server took to process the request, in milliseconds.
      example: 20
    RedirectRuleIndexMetadata:
      type: object
      properties:
        data:
          title: redirectRuleIndexData
          type: object
          description: Redirect rule data.
          required:
            - ruleObjectID
          properties:
            ruleObjectID:
              type: string
        dest:
          type: string
          description: Destination index for the redirect rule.
        reason:
          type: string
          description: Reason for the redirect rule.
        source:
          type: string
          description: Source index for the redirect rule.
        succeed:
          type: boolean
          description: Redirect rule status.
      required:
        - data
        - succeed
        - reason
        - dest
        - source
    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
    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
    hits:
      type: array
      description: >
        Search results (hits).


        Hits are records from your index that match the search criteria,
        augmented with additional attributes, such as, for highlighting.
      items:
        $ref: '#/components/schemas/hit'
    SingleResultSet_hitsPerPage:
      type: integer
      description: Number of hits returned per page.
      example: 20
    nbHits:
      type: integer
      description: Number of results (hits).
      example: 20
    nbPages:
      type: integer
      description: Number of pages of results.
      example: 1
    SingleResultSet_page:
      type: integer
      description: The current page of the results.
      example: 0
    SingleResultSet_params:
      type: string
      description: URL-encoded string of all search parameters.
      example: query=a&hitsPerPage=20
    SingleResultSet_query:
      type: string
      description: The search query string.
      example: shoes
    resultsCompositionInfoResponse:
      type: object
      x-additionalPropertiesName: composition-id
      properties:
        injectedItems:
          type: array
          items:
            $ref: '#/components/schemas/resultsInjectedItemInfoResponse'
      required:
        - injectedItems
    feedID:
      type: string
      description: The ID of the feed.
      example: products-feed
    facetOrdering:
      description: Order of facet names and facet values in your UI.
      type: object
      additionalProperties: false
      properties:
        facets:
          $ref: '#/components/schemas/IndexSettings_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'
    hit:
      type: object
      description: >
        Search result.


        A hit is a record from your index, augmented with special attributes for
        highlighting, snippeting, and ranking.
      x-is-generic: true
      additionalProperties: true
      required:
        - objectID
      properties:
        objectID:
          $ref: '#/components/schemas/objectID'
        _distinctSeqID:
          $ref: '#/components/schemas/distinctSeqID'
        _extra:
          $ref: '#/components/schemas/hitMetadata'
        _highlightResult:
          $ref: '#/components/schemas/highlightResultMap'
        _rankingInfo:
          $ref: '#/components/schemas/Hit_rankingInfo'
        _snippetResult:
          $ref: '#/components/schemas/snippetResultMap'
    resultsInjectedItemInfoResponse:
      type: object
      additionalProperties: true
      properties:
        key:
          type: string
          description: The key of the injected group.
          example: men-sponsored-group
        appliedRules:
          type: array
          items:
            $ref: '#/components/schemas/resultsInjectedItemAppliedRulesInfoResponse'
      required:
        - key
    IndexSettings_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'
    objectID:
      type: string
      description: Unique record identifier.
      example: test-record-123
    distinctSeqID:
      type: integer
    hitMetadata:
      type: object
      description: >-
        An object that contains the extra key-value pairs provided in the
        injectedItem definition.
      additionalProperties: true
      properties:
        _injectedItemKey:
          type: string
          description: The key of the injectedItem that inserted this metadata.
    highlightResultMap:
      title: highlightResultMap
      type: object
      description: Surround words that match the query with HTML tags for highlighting.
      x-is-free-form: false
      additionalProperties:
        $ref: '#/components/schemas/highlightResult'
        x-additionalPropertiesName: attribute
    Hit_rankingInfo:
      type: object
      properties:
        firstMatchedWord:
          type: integer
          minimum: 0
          description: >-
            Position of the first matched word in the best matching attribute of
            the record.
        geoDistance:
          type: integer
          minimum: 0
          description: >-
            Distance between the geo location in the search query and the best
            matching geo location in the record, divided by the geo precision
            (in meters).
        nbExactWords:
          type: integer
          minimum: 0
          description: Number of exactly matched words.
        nbTypos:
          type: integer
          minimum: 0
          description: Number of typos encountered when matching the record.
        userScore:
          type: integer
          description: >-
            Overall ranking of the record, expressed as a single integer. This
            attribute is internal.
        composed:
          title: composedRankingInfo
          type: object
          additionalProperties:
            title: compositionIdRankingInfo
            x-additionalPropertiesName: composition-id
            type: object
            properties:
              index:
                type: string
                example: products
              injectedItemKey:
                type: string
                example: sponsored-products
            required:
              - index
              - injectedItemKey
          example:
            my-composition-to-sponsor-products:
              index: products
              injectedItemKey: sponsored-products
        filters:
          type: integer
          minimum: 0
          description: Whether a filter matched the query.
        geoPrecision:
          type: integer
          minimum: 1
          description: Precision used when computing the geo distance, in meters.
        matchedGeoLocation:
          $ref: '#/components/schemas/matchedGeoLocation'
        personalization:
          $ref: '#/components/schemas/personalization'
        promoted:
          type: boolean
          description: Whether the record was promoted by a rule.
        promotedByReRanking:
          type: boolean
          description: Whether the record is re-ranked.
        proximityDistance:
          type: integer
          minimum: 0
          description: >-
            Number of words between multiple matches in the query plus 1. For
            single word queries, `proximityDistance` is 0.
        words:
          type: integer
          minimum: 1
          description: Number of matched words.
      required:
        - nbTypos
        - firstMatchedWord
        - geoDistance
        - nbExactWords
        - userScore
      additionalProperties: false
      description: Object with detailed information about the record's ranking.
    snippetResultMap:
      title: snippetResultMap
      type: object
      description: Snippets that show the context around a matching search query.
      x-is-free-form: false
      additionalProperties:
        $ref: '#/components/schemas/snippetResult'
        x-additionalPropertiesName: attribute
    resultsInjectedItemAppliedRulesInfoResponse:
      type: object
      properties:
        objectID:
          type: string
          description: The objectID of the applied index level rule on this injected group.
      example:
        objectID: qr-1765458959657
      required:
        - objectID
    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'
    highlightResult:
      oneOf:
        - $ref: '#/components/schemas/highlightResultOption'
        - $ref: '#/components/schemas/highlightResultMap'
        - $ref: '#/components/schemas/highlightResultArray'
    matchedGeoLocation:
      type: object
      properties:
        distance:
          type: integer
          description: >-
            Distance between the matched location and the search location (in
            meters).
        lat:
          type: number
          format: double
          description: Latitude of the matched location.
        lng:
          type: number
          format: double
          description: Longitude of the matched location.
    personalization:
      type: object
      properties:
        filtersScore:
          type: integer
          description: The score of the filters.
        rankingScore:
          type: integer
          description: The score of the ranking.
        score:
          type: integer
          description: The score of the event.
    snippetResult:
      oneOf:
        - $ref: '#/components/schemas/snippetResultOption'
        - $ref: '#/components/schemas/snippetResultMap'
        - $ref: '#/components/schemas/snippetResultArray'
    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
    highlightResultOption:
      title: highlightResultOption
      type: object
      description: Surround words that match the query with HTML tags for highlighting.
      additionalProperties: false
      properties:
        matchedWords:
          type: array
          description: List of matched words from the search query.
          example:
            - action
          items:
            type: string
        matchLevel:
          $ref: '#/components/schemas/matchLevel'
        value:
          $ref: '#/components/schemas/highlightedValue'
        fullyHighlighted:
          type: boolean
          description: Whether the entire attribute value is highlighted.
      required:
        - value
        - matchLevel
        - matchedWords
      x-discriminator-fields:
        - matchLevel
        - matchedWords
    highlightResultArray:
      title: highlightResultArray
      type: array
      description: Surround words that match the query with HTML tags for highlighting.
      items:
        $ref: '#/components/schemas/highlightResult'
    snippetResultOption:
      title: snippetResultOption
      type: object
      description: Snippets that show the context around a matching search query.
      additionalProperties: false
      properties:
        matchLevel:
          $ref: '#/components/schemas/matchLevel'
        value:
          $ref: '#/components/schemas/highlightedValue'
      required:
        - value
        - matchLevel
      x-discriminator-fields:
        - matchLevel
    snippetResultArray:
      title: snippetResultArray
      type: array
      description: Snippets that show the context around a matching search query.
      items:
        $ref: '#/components/schemas/snippetResult'
    bannerImageUrl:
      description: URL for an image to show inside a banner.
      type: object
      additionalProperties: false
      properties:
        url:
          type: string
    matchLevel:
      type: string
      description: Whether the whole query string matches or only a part.
      enum:
        - none
        - partial
        - full
    highlightedValue:
      type: string
      description: Highlighted attribute value, including HTML tags.
      example: <em>George</em> <em>Clo</em>oney
  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.

````