openapi: 3.0.2
info:
  title: Algolia Recommend API
  description: >-
    Algolia Recommend API is a powerful tool that leverages machine learning
    algorithms to provide personalized recommendations to users based on their
    behavior and preferences. By analyzing user interactions, search history,
    and other data points, the API can suggest relevant products, content, or
    services to drive engagement and increase conversion rates. With
    customizable algorithms and real-time updates, Algolia Recommend API helps
    businesses deliver a seamless and highly personalized user experience that
    can ultimately lead to higher customer satisfaction and loyalty.
  version: 1.0.0
servers:
  - url: https://{appId}.algolianet.com
    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.algolianet.com
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
security:
  - appId: []
    apiKey: []
tags:
  - name: recommendations
    x-displayName: Recommendations
    description: >-
      Retrieve recommendations from a pre-trained AI model. You can train models
      in the [Algolia dashboard](https://dashboard.algolia.com/recommend/).
    externalDocs:
      url: https://www.algolia.com/doc/guides/algolia-recommend/overview/
      description: |
        Related guide: Algolia Recommend.
  - name: rules
    x-displayName: Rules
    description: Curate your recommendations with rules, which are _if_-_then_ statements.
    externalDocs:
      url: https://www.algolia.com/doc/guides/algolia-recommend/how-to/rules/
      description: |
        Related guide: Recommend Rules.
paths:
  /{path}:
    get:
      operationId: customGet
      summary: Send requests to the Algolia REST API
      description: This method allow you to send requests to the Algolia REST API.
      parameters:
        - $ref: '#/components/parameters/PathInPath'
        - $ref: '#/components/parameters/Parameters'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
      tags:
        - recommend
    post:
      operationId: customPost
      requestBody:
        description: Parameters to send with the custom request.
        content:
          application/json:
            schema:
              type: object
      summary: Send requests to the Algolia REST API
      description: This method allow you to send requests to the Algolia REST API.
      parameters:
        - $ref: '#/components/parameters/PathInPath'
        - $ref: '#/components/parameters/Parameters'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
      tags:
        - recommend
    put:
      operationId: customPut
      requestBody:
        description: Parameters to send with the custom request.
        content:
          application/json:
            schema:
              type: object
      summary: Send requests to the Algolia REST API
      description: This method allow you to send requests to the Algolia REST API.
      parameters:
        - $ref: '#/components/parameters/PathInPath'
        - $ref: '#/components/parameters/Parameters'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
      tags:
        - recommend
    delete:
      operationId: customDelete
      summary: Send requests to the Algolia REST API
      description: This method allow you to send requests to the Algolia REST API.
      parameters:
        - $ref: '#/components/parameters/PathInPath'
        - $ref: '#/components/parameters/Parameters'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                type: object
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
      tags:
        - recommend
  /1/indexes/*/recommendations:
    post:
      tags:
        - recommend
      operationId: getRecommendations
      x-use-read-transporter: true
      x-cacheable: true
      x-acl:
        - search
      x-legacy-signature-recommend: true
      summary: Retrieve recommendations
      description: |
        Retrieves recommendations from selected AI models.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              title: getRecommendationsParams
              description: Recommend request body.
              type: object
              additionalProperties: false
              properties:
                requests:
                  type: array
                  description: >-
                    Recommendation request with parameters depending on the
                    requested model.
                  items:
                    $ref: '#/components/schemas/recommendationsRequest'
              required:
                - requests
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                title: getRecommendationsResponse
                type: object
                additionalProperties: false
                properties:
                  results:
                    type: array
                    items:
                      $ref: '#/components/schemas/recommendationsResults'
                required:
                  - results
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
  /1/indexes/{indexName}/{model}/recommend/rules/{objectID}:
    get:
      tags:
        - recommend
      operationId: getRecommendRule
      x-acl:
        - settings
      summary: Retrieve a rule
      description: >-
        Retrieves a Recommend rule that you previously created in the Algolia
        dashboard.
      parameters:
        - $ref: '#/components/parameters/IndexName'
        - $ref: '#/components/parameters/Models'
        - $ref: '#/components/parameters/ObjectID'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/RecommendRule'
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
    delete:
      tags:
        - recommend
      operationId: deleteRecommendRule
      x-acl:
        - editSettings
      summary: Delete a rule
      description: Deletes a Recommend rule from a recommendation scenario.
      parameters:
        - $ref: '#/components/parameters/IndexName'
        - $ref: '#/components/parameters/Models'
        - $ref: '#/components/parameters/ObjectID'
      responses:
        '200':
          $ref: '#/components/responses/DeletedAt'
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
  /1/indexes/{indexName}/{model}/task/{taskID}:
    get:
      tags:
        - recommend
      operationId: getRecommendStatus
      x-acl:
        - editSettings
      summary: Check task status
      description: >
        Checks the status of a given task.


        Deleting a Recommend rule is asynchronous.

        When you delete a rule, a task is created on a queue and completed
        depending on the load on the server.

        The API response includes a task ID that you can use to check the
        status.
      parameters:
        - $ref: '#/components/parameters/IndexName'
        - $ref: '#/components/parameters/Models'
        - name: taskID
          in: path
          description: Unique task identifier.
          required: true
          schema:
            $ref: '#/components/schemas/taskID'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                title: getRecommendTaskResponse
                type: object
                additionalProperties: false
                properties:
                  status:
                    $ref: '#/components/schemas/taskStatus'
                required:
                  - status
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
  /1/indexes/{indexName}/{model}/recommend/rules/search:
    post:
      tags:
        - recommend
      operationId: searchRecommendRules
      x-use-read-transporter: true
      x-cacheable: true
      x-acl:
        - settings
      summary: Search for rules
      description: |
        Searches for Recommend rules.

        Use an empty query to list all rules for this recommendation scenario.
      parameters:
        - $ref: '#/components/parameters/IndexName'
        - $ref: '#/components/parameters/Models'
      requestBody:
        content:
          application/json:
            schema:
              title: searchRecommendRulesParams
              type: object
              description: Recommend rules parameters.
              additionalProperties: false
              properties:
                query:
                  $ref: '#/components/schemas/parameters_query'
                context:
                  type: string
                  description: Only search for rules with matching context.
                  example: mobile
                page:
                  $ref: '#/components/schemas/parameters_page'
                hitsPerPage:
                  $ref: '#/components/schemas/parameters_hitsPerPage'
                enabled:
                  type: boolean
                  description: >
                    Whether to only show rules where the value of their
                    `enabled` property matches this parameter.

                    If absent, show all rules, regardless of their `enabled`
                    property.
                filters:
                  type: string
                  description: >-
                    Filter expression. This only searches for rules matching the
                    filter expression.
                  example: objectID:rr-123456
                facets:
                  type: array
                  description: >-
                    Include facets and facet values in the response. Use `['*']`
                    to include all facets.
                  example:
                    - '*'
                  items:
                    type: string
                    description: Facet name for rule objects or `*` as wildcard character.
                    example: condition.context
                maxValuesPerFacet:
                  type: integer
                  description: Maximum number of values to return for each facet.
                  minimum: 1
                  maximum: 1000
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                title: searchRecommendRulesResponse
                type: object
                additionalProperties: false
                required:
                  - hits
                  - nbHits
                  - page
                  - nbPages
                properties:
                  hits:
                    type: array
                    description: Recommend rules that match the search criteria.
                    items:
                      $ref: '#/components/schemas/RecommendRule'
                  nbHits:
                    $ref: '#/components/schemas/nbHits'
                  page:
                    $ref: '#/components/schemas/page'
                  nbPages:
                    $ref: '#/components/schemas/nbPages'
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
  /1/indexes/{indexName}/{model}/recommend/rules/batch:
    post:
      tags:
        - recommend
      operationId: batchRecommendRules
      x-acl:
        - editSettings
      summary: Create or update a batch of Recommend Rules
      description: >
        Create or update a batch of Recommend Rules


        Each Recommend Rule is created or updated, depending on whether a
        Recommend Rule with the same `objectID` already exists.

        You may also specify `true` for `clearExistingRules`, in which case the
        batch will atomically replace all the existing Recommend Rules.


        Recommend Rules are similar to Search Rules, except that the conditions
        and consequences apply to a [source
        item](/doc/guides/algolia-recommend/overview/#recommend-models) instead
        of a query. The main differences are the following:

        - Conditions `pattern` and `anchoring` are unavailable.

        - Condition `filters` triggers if the source item matches the specified
        filters.

        - Condition `filters` accepts numeric filters.

        - Consequence `params` only covers filtering parameters.

        - Consequence `automaticFacetFilters` doesn't require a facet value
        placeholder (it tries to match the data source item's attributes
        instead).
      parameters:
        - $ref: '#/components/parameters/IndexName'
        - $ref: '#/components/parameters/Models'
      requestBody:
        content:
          application/json:
            schema:
              title: rules
              type: array
              description: Recommend rules.
              items:
                $ref: '#/components/schemas/RecommendRule'
      responses:
        '200':
          $ref: '#/components/responses/RecommendUpdatedAt'
        '400':
          $ref: '#/components/responses/BadRequest'
  /setClientApiKey:
    get:
      x-helper: true
      x-asynchronous-helper: false
      tags:
        - recommend
      operationId: setClientApiKey
      summary: Switch the API key used to authenticate requests
      description: |
        Switch the API key used to authenticate requests.
      parameters:
        - in: query
          name: apiKey
          description: API key to be used from now on.
          required: true
          schema:
            type: string
      responses:
        '204':
          description: No content.
components:
  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.
  parameters:
    PathInPath:
      name: path
      in: path
      description: Path of the endpoint, anything after "/1" must be specified.
      required: true
      schema:
        type: string
        example: /keys
    Parameters:
      name: parameters
      in: query
      description: Query parameters to apply to the current query.
      schema:
        type: object
        additionalProperties: true
    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
    Models:
      in: path
      name: model
      required: true
      description: >
        [Recommend
        model](https://www.algolia.com/doc/guides/algolia-recommend/overview/#recommend-models).
      schema:
        $ref: '#/components/schemas/recommendModels'
    ObjectID:
      name: objectID
      in: path
      description: Unique record identifier.
      required: true
      schema:
        $ref: '#/components/schemas/objectID'
  schemas:
    ErrorBase:
      description: Error.
      type: object
      x-keep-model: true
      additionalProperties: true
      properties:
        message:
          type: string
          example: Invalid Application-Id or API-Key
    indexName:
      type: string
      example: products
      description: Index name (case-sensitive).
    similarQuery:
      type: string
      description: >
        Keywords to be used instead of the search query to conduct a more
        broader search.


        Using the `similarQuery` parameter changes other settings:


        - `queryType` is set to `prefixNone`.

        - `removeStopWords` is set to true.

        - `words` is set as the first ranking criterion.

        - All remaining words are treated as `optionalWords`.


        Since the `similarQuery` is supposed to do a broad search, they usually
        return many results.

        Combine it with `filters` to narrow down the list of results.
      default: ''
      example: comedy drama crime Macy Buscemi
      x-categories:
        - Search
    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 around your filters, if the facet attribute name or facet
        value has spaces, keywords (`OR`, `AND`, `NOT`), or quotes.

        If a facet attribute is an array, the filter matches if it matches at
        least one element of the array.


        For more information, see
        [Filters](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/).
      example: (category:Book OR category:Ebook) AND _tags:published
      x-categories:
        - Filtering
    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
    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 don't work on virtual replicas.

        - Optional filters are applied _after_ sort-by attributes.

        - Optional filters are applied _before_ custom ranking attributes (in
        the default
        [ranking](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/)).

        - Optional filters don't work with numeric attributes.
      example:
        - category:Book
        - author:John Doe
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/optionalFilters'
        - type: string
      x-categories:
        - Filtering
    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
    tagFilters:
      description: >
        Filter the search by values of the special `_tags` attribute.


        **Prefer using the `filters` parameter, which supports all filter types
        and combinations with boolean operators.**


        Different from regular facets, `_tags` can only be used for filtering
        (including or excluding records).

        You won't get a facet count.

        The same combination and escaping rules apply as for `facetFilters`.
      example:
        - - Book
          - Movie
        - SciFi
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/tagFilters'
        - type: string
      x-categories:
        - Filtering
    sumOrFiltersScores:
      type: boolean
      description: >
        Whether to sum all filter scores.


        If true, all filter scores are summed.

        Otherwise, the maximum filter score is kept.

        For more information, see [filter
        scores](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/in-depth/filter-scoring/#accumulating-scores-with-sumorfiltersscores).
      default: false
      x-categories:
        - Filtering
    restrictSearchableAttributes:
      type: array
      items:
        type: string
      example:
        - title
        - author
      description: |
        Restricts a search to a subset of your searchable attributes.
        Attribute names are case-sensitive.
      default: []
      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 `*`.

        For more information, see
        [facets](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#contextual-facet-values-and-counts).
      default: []
      example:
        - '*'
      x-categories:
        - Faceting
    facetingAfterDistinct:
      type: boolean
      description: >
        Whether faceting should be applied after deduplication with `distinct`.


        This leads to accurate facet counts when using faceting in combination
        with `distinct`.

        It's usually better to use `afterDistinct` modifiers in the
        `attributesForFaceting` setting,

        as `facetingAfterDistinct` only computes correct facet counts if all
        records have the same facet values for the `attributeForDistinct`.
      default: false
      x-categories:
        - Faceting
    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
    aroundRadiusAll:
      title: all
      type: string
      description: >-
        Return all records with a valid `_geoloc` attribute. Don't filter by
        distance.
      enum:
        - all
    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
    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.
    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
    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
    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
    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
    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
    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
    ruleContexts:
      type: array
      items:
        type: string
      description: >
        Assigns a rule context to the search query.


        [Rule
        contexts](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/how-to/customize-search-results-by-platform/#whats-a-context)
        are strings that you can use to trigger matching rules.
      default: []
      example:
        - mobile
      x-categories:
        - Rules
    personalizationImpact:
      type: integer
      description: >
        Impact that Personalization should have on this search.


        The higher this value is, the more Personalization determines the
        ranking compared to other factors.

        For more information, see [Understanding Personalization
        impact](https://www.algolia.com/doc/guides/personalization/personalizing-results/in-depth/configuring-personalization/#understanding-personalization-impact).
      default: 100
      minimum: 0
      maximum: 100
      x-categories:
        - Personalization
    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
    getRankingInfo:
      type: boolean
      description: Whether the search response should include detailed ranking information.
      default: false
      x-categories:
        - Advanced
    synonyms:
      type: boolean
      description: Whether to take into account an index's synonyms for this search.
      default: true
      x-categories:
        - Advanced
    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/guides/sending-events/getting-started/).
      default: false
      x-categories:
        - Analytics
    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: []
      x-categories:
        - Analytics
    percentileComputation:
      type: boolean
      description: >-
        Whether to include this search when calculating processing-time
        percentiles.
      default: true
      x-categories:
        - Advanced
    enableABTest:
      type: boolean
      description: Whether to enable A/B testing for this search.
      default: true
      x-categories:
        - Advanced
    baseRecommendSearchParams:
      type: object
      additionalProperties: false
      properties:
        similarQuery:
          $ref: '#/components/schemas/similarQuery'
        filters:
          $ref: '#/components/schemas/filters'
        facetFilters:
          $ref: '#/components/schemas/facetFilters'
        optionalFilters:
          $ref: '#/components/schemas/optionalFilters'
        numericFilters:
          $ref: '#/components/schemas/numericFilters'
        tagFilters:
          $ref: '#/components/schemas/tagFilters'
        sumOrFiltersScores:
          $ref: '#/components/schemas/sumOrFiltersScores'
        restrictSearchableAttributes:
          $ref: '#/components/schemas/restrictSearchableAttributes'
        facets:
          $ref: '#/components/schemas/facets'
        facetingAfterDistinct:
          $ref: '#/components/schemas/facetingAfterDistinct'
        aroundLatLng:
          $ref: '#/components/schemas/aroundLatLng'
        aroundLatLngViaIP:
          $ref: '#/components/schemas/aroundLatLngViaIP'
        aroundRadius:
          $ref: '#/components/schemas/aroundRadius'
        aroundPrecision:
          $ref: '#/components/schemas/aroundPrecision'
        minimumAroundRadius:
          $ref: '#/components/schemas/minimumAroundRadius'
        insideBoundingBox:
          $ref: '#/components/schemas/insideBoundingBox'
        insidePolygon:
          $ref: '#/components/schemas/insidePolygon'
        naturalLanguages:
          $ref: '#/components/schemas/naturalLanguages'
        ruleContexts:
          $ref: '#/components/schemas/ruleContexts'
        personalizationImpact:
          $ref: '#/components/schemas/personalizationImpact'
        userToken:
          $ref: '#/components/schemas/userToken'
        getRankingInfo:
          $ref: '#/components/schemas/getRankingInfo'
        synonyms:
          $ref: '#/components/schemas/synonyms'
        clickAnalytics:
          $ref: '#/components/schemas/clickAnalytics'
        analytics:
          $ref: '#/components/schemas/analytics'
        analyticsTags:
          $ref: '#/components/schemas/analyticsTags'
        percentileComputation:
          $ref: '#/components/schemas/percentileComputation'
        enableABTest:
          $ref: '#/components/schemas/enableABTest'
    query:
      type: string
      description: Search query.
      default: ''
      x-categories:
        - Search
    searchParamsQuery:
      type: object
      additionalProperties: false
      properties:
        query:
          $ref: '#/components/schemas/query'
    userData:
      type: object
      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
    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
    baseIndexSettings:
      type: object
      additionalProperties: false
      properties:
        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
        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
        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
        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
        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
        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
        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 languagesfor 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
        indexLanguages:
          type: array
          items:
            $ref: '#/components/schemas/supportedLanguage'
          example:
            - ja
          description: >
            Languages for language-specific processing steps, such as word
            detection and dictionary settings.


            **You should 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
        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
        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
        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
        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
        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
        userData:
          $ref: '#/components/schemas/userData'
        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
        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
        maxFacetHits:
          $ref: '#/components/schemas/maxFacetHits'
        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
        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
    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
    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,

        you should 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:
      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
    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
    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
    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
    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
    snippetEllipsisText:
      type: string
      description: String used as an ellipsis indicator when a snippet is truncated.
      default: &
      x-categories:
        - Highlighting and Snippeting
    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
    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
    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
    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
    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
    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
    booleanString:
      type: string
      enum:
        - 'true'
        - 'false'
    ignorePlurals:
      description: |
        Treat singular, plurals, and other forms of declensions as equivalent.
        You should 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
    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.


        You should 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
    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, you must place the CJK language **first**.


        **You should always specify a query language.**

        If you don't specify an indexing language, the search engine uses all
        [supported
        languages](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/),

        or the languages you specified with the `ignorePlurals` or
        `removeStopWords` parameters.

        This can lead to unexpected search results.

        For more information, see [Language-specific
        configuration](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations/).
      default: []
      x-categories:
        - Languages
    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
    enableRules:
      type: boolean
      description: Whether to enable rules.
      default: true
      x-categories:
        - Rules
    enablePersonalization:
      type: boolean
      description: Whether to enable Personalization.
      default: false
      x-categories:
        - Personalization
    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
    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
    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
    optionalWordsArray:
      type: array
      items:
        type: string
      example:
        - blue
        - iphone case
      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 help to increase the number of search results
        by running an additional search query that doesn't include the optional
        words.

        For example, if the search query is "action video" and "video" is an
        optional word,

        the search engine runs two queries. One for "action video" and one for
        "action".

        Records that match all words are ranked higher.


        For a search query with 4 or more words **and** all its words are
        optional,

        the number of matched words required for a record to be included in the
        search results increases for every 1,000 records:


        - If `optionalWords` has less than 10 words, the required number of
        matched words increases by 1:
          results 1 to 1,000 require 1 matched word, results 1,001 to 2000 need 2 matched words.
        - If `optionalWords` has 10 or more words, the number of required
        matched words increases by the number of optional words divided by 5
        (rounded down).
          For example, with 18 optional words: results 1 to 1,000 require 1 matched word, results 1,001 to 2000 need 4 matched words.

        For more information, see [Optional
        words](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/empty-or-insufficient-results/#creating-a-list-of-optional-words).
      default: []
      x-categories:
        - Query strategy
    optionalWords:
      oneOf:
        - type: string
        - type: 'null'
        - $ref: '#/components/schemas/optionalWordsArray'
    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
    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
    alternativesAsExact:
      type: string
      enum:
        - ignorePlurals
        - singleWordSynonym
        - multiWordsSynonym
        - ignoreConjugations
      x-categories:
        - Query strategy
    properties-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
    advancedSyntaxFeatures:
      type: string
      enum:
        - exactPhrase
        - excludeWords
      x-categories:
        - Query strategy
    properties-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
    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
    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
    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
    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
    maxValuesPerFacet:
      type: integer
      description: Maximum number of facet values to return for each facet.
      default: 100
      maximum: 1000
      x-categories:
        - Faceting
    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
    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
    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
    IndexSettings_facets:
      description: Order of facet names.
      type: object
      additionalProperties: false
      properties:
        order:
          $ref: '#/components/schemas/order'
    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
    hide:
      description: Hide facet values.
      type: array
      items:
        type: string
    value:
      type: object
      additionalProperties: false
      properties:
        order:
          $ref: '#/components/schemas/order'
        sortRemainingBy:
          $ref: '#/components/schemas/sortRemainingBy'
        hide:
          $ref: '#/components/schemas/hide'
    values:
      description: Order of facet values. One object for each facet.
      type: object
      additionalProperties:
        x-additionalPropertiesName: facet
        $ref: '#/components/schemas/value'
    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
    bannerImageUrl:
      description: URL for an image to show inside a banner.
      type: object
      additionalProperties: false
      properties:
        url:
          type: string
    bannerImage:
      description: Image to show inside a banner.
      type: object
      additionalProperties: false
      properties:
        urls:
          type: array
          items:
            $ref: '#/components/schemas/bannerImageUrl'
        title:
          type: string
    bannerLink:
      description: Link for a banner defined in the Merchandising Studio.
      type: object
      additionalProperties: false
      properties:
        url:
          type: string
    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'
    banners:
      description: Banners defined in the Merchandising Studio for a given search.
      type: array
      items:
        $ref: '#/components/schemas/banner'
    widgets:
      description: Widgets returned from any rules that are applied to the current search.
      type: object
      additionalProperties: false
      properties:
        banners:
          $ref: '#/components/schemas/banners'
    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
    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
    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
    properties-reRankingApplyFilter:
      oneOf:
        - $ref: '#/components/schemas/reRankingApplyFilter'
        - type: 'null'
    baseRecommendIndexSettings:
      type: object
      additionalProperties: false
      properties:
        attributesToRetrieve:
          $ref: '#/components/schemas/attributesToRetrieve'
        ranking:
          $ref: '#/components/schemas/ranking'
        relevancyStrictness:
          $ref: '#/components/schemas/relevancyStrictness'
        attributesToHighlight:
          $ref: '#/components/schemas/attributesToHighlight'
        attributesToSnippet:
          $ref: '#/components/schemas/attributesToSnippet'
        highlightPreTag:
          $ref: '#/components/schemas/highlightPreTag'
        highlightPostTag:
          $ref: '#/components/schemas/highlightPostTag'
        snippetEllipsisText:
          $ref: '#/components/schemas/snippetEllipsisText'
        restrictHighlightAndSnippetArrays:
          $ref: '#/components/schemas/restrictHighlightAndSnippetArrays'
        minWordSizefor1Typo:
          $ref: '#/components/schemas/minWordSizefor1Typo'
        minWordSizefor2Typos:
          $ref: '#/components/schemas/minWordSizefor2Typos'
        typoTolerance:
          $ref: '#/components/schemas/typoTolerance'
        allowTyposOnNumericTokens:
          $ref: '#/components/schemas/allowTyposOnNumericTokens'
        disableTypoToleranceOnAttributes:
          $ref: '#/components/schemas/disableTypoToleranceOnAttributes'
        ignorePlurals:
          $ref: '#/components/schemas/ignorePlurals'
        removeStopWords:
          $ref: '#/components/schemas/removeStopWords'
        queryLanguages:
          $ref: '#/components/schemas/queryLanguages'
        decompoundQuery:
          $ref: '#/components/schemas/decompoundQuery'
        enableRules:
          $ref: '#/components/schemas/enableRules'
        enablePersonalization:
          $ref: '#/components/schemas/enablePersonalization'
        queryType:
          $ref: '#/components/schemas/queryType'
        removeWordsIfNoResults:
          $ref: '#/components/schemas/removeWordsIfNoResults'
        advancedSyntax:
          $ref: '#/components/schemas/advancedSyntax'
        optionalWords:
          $ref: '#/components/schemas/optionalWords'
        disableExactOnAttributes:
          $ref: '#/components/schemas/disableExactOnAttributes'
        exactOnSingleWordQuery:
          $ref: '#/components/schemas/exactOnSingleWordQuery'
        alternativesAsExact:
          $ref: '#/components/schemas/properties-alternativesAsExact'
        advancedSyntaxFeatures:
          $ref: '#/components/schemas/properties-advancedSyntaxFeatures'
        distinct:
          $ref: '#/components/schemas/distinct'
        replaceSynonymsInHighlight:
          $ref: '#/components/schemas/replaceSynonymsInHighlight'
        minProximity:
          $ref: '#/components/schemas/minProximity'
        responseFields:
          $ref: '#/components/schemas/responseFields'
        maxValuesPerFacet:
          $ref: '#/components/schemas/maxValuesPerFacet'
        sortFacetValuesBy:
          $ref: '#/components/schemas/sortFacetValuesBy'
        attributeCriteriaComputedByMinProximity:
          $ref: '#/components/schemas/attributeCriteriaComputedByMinProximity'
        renderingContent:
          $ref: '#/components/schemas/renderingContent'
        enableReRanking:
          $ref: '#/components/schemas/enableReRanking'
        reRankingApplyFilter:
          $ref: '#/components/schemas/properties-reRankingApplyFilter'
    recommendIndexSettings:
      description: Index settings.
      allOf:
        - $ref: '#/components/schemas/baseIndexSettings'
        - $ref: '#/components/schemas/baseRecommendIndexSettings'
    recommendSearchParams:
      title: Search parameters as object
      description: Search parameters for filtering the recommendations.
      allOf:
        - $ref: '#/components/schemas/baseRecommendSearchParams'
        - $ref: '#/components/schemas/searchParamsQuery'
        - $ref: '#/components/schemas/recommendIndexSettings'
    baseRecommendRequest:
      type: object
      additionalProperties: false
      properties:
        indexName:
          $ref: '#/components/schemas/indexName'
        threshold:
          type: number
          format: double
          minimum: 0
          maximum: 100
          description: >-
            Minimum score a recommendation must have to be included in the
            response.
        maxRecommendations:
          type: integer
          minimum: 1
          maximum: 1000
          default: 30
          description: >
            Maximum number of recommendations to retrieve.

            By default, all recommendations are returned and no fallback request
            is made.

            Depending on the available recommendations and the other request
            parameters,

            the actual number of recommendations may be lower than this value.
        queryParameters:
          $ref: '#/components/schemas/recommendSearchParams'
      required:
        - indexName
        - threshold
    fbtModel:
      type: string
      description: >
        Frequently bought together model.


        This model recommends items that have been purchased within 1 day with
        the item with the ID `objectID`.
      enum:
        - bought-together
    objectID:
      type: string
      description: Unique record identifier.
      example: test-record-123
    frequentlyBoughtTogether:
      type: object
      properties:
        model:
          $ref: '#/components/schemas/fbtModel'
        objectID:
          $ref: '#/components/schemas/objectID'
      required:
        - model
        - objectID
    boughtTogetherQuery:
      title: Frequently bought together
      allOf:
        - $ref: '#/components/schemas/baseRecommendRequest'
        - $ref: '#/components/schemas/frequentlyBoughtTogether'
    relatedModel:
      type: string
      description: >
        Related products or similar content model.


        This model recommends items that are similar to the item with the ID
        `objectID`.

        Similarity is determined from the user interactions and attributes.
      enum:
        - related-products
    fallbackParams:
      title: fallbackParameters
      allOf:
        - $ref: '#/components/schemas/recommendSearchParams'
        - type: object
          description: >-
            Search parameters to use for a fallback request if there aren't
            enough recommendations.
    relatedProducts:
      type: object
      properties:
        model:
          $ref: '#/components/schemas/relatedModel'
        objectID:
          $ref: '#/components/schemas/objectID'
        fallbackParameters:
          $ref: '#/components/schemas/fallbackParams'
      required:
        - model
        - objectID
    relatedQuery:
      title: Related products
      allOf:
        - $ref: '#/components/schemas/baseRecommendRequest'
        - $ref: '#/components/schemas/relatedProducts'
    facetName:
      type: string
      description: >
        Facet attribute. To be used in combination with `facetValue`.

        If specified, only recommendations matching the facet filter will be
        returned.
    facetValue:
      type: string
      description: >
        Facet value. To be used in combination with `facetName`.

        If specified, only recommendations matching the facet filter will be
        returned.
    trendingItemsModel:
      description: >
        Trending items model.


        Trending items are determined from the number of conversion events
        collected on them.
      type: string
      enum:
        - trending-items
    trendingItems:
      type: object
      properties:
        facetName:
          $ref: '#/components/schemas/facetName'
        facetValue:
          $ref: '#/components/schemas/facetValue'
        model:
          $ref: '#/components/schemas/trendingItemsModel'
        fallbackParameters:
          $ref: '#/components/schemas/fallbackParams'
      required:
        - model
    trendingItemsQuery:
      title: Trending items
      allOf:
        - $ref: '#/components/schemas/baseRecommendRequest'
        - $ref: '#/components/schemas/trendingItems'
    trendingFacetsModel:
      type: string
      description: >
        Trending facet values model.


        This model recommends trending facet values for the specified facet
        attribute.
      enum:
        - trending-facets
    trendingFacets:
      type: object
      properties:
        facetName:
          type: string
          description: Facet attribute for which to retrieve trending facet values.
        model:
          $ref: '#/components/schemas/trendingFacetsModel'
        fallbackParameters:
          $ref: '#/components/schemas/fallbackParams'
      required:
        - facetName
        - model
    trendingFacetsQuery:
      title: Trending facet values
      allOf:
        - $ref: '#/components/schemas/baseRecommendRequest'
        - $ref: '#/components/schemas/trendingFacets'
    lookingSimilarModel:
      type: string
      description: >
        Looking similar model.


        This model recommends items that look similar to the item with the ID
        `objectID` based on image attributes in your index.
      enum:
        - looking-similar
    lookingSimilar:
      type: object
      properties:
        model:
          $ref: '#/components/schemas/lookingSimilarModel'
        objectID:
          $ref: '#/components/schemas/objectID'
        fallbackParameters:
          $ref: '#/components/schemas/fallbackParams'
      required:
        - model
        - objectID
    lookingSimilarQuery:
      title: Looking similar
      allOf:
        - $ref: '#/components/schemas/baseRecommendRequest'
        - $ref: '#/components/schemas/lookingSimilar'
    recommendationsRequest:
      oneOf:
        - $ref: '#/components/schemas/boughtTogetherQuery'
        - $ref: '#/components/schemas/relatedQuery'
        - $ref: '#/components/schemas/trendingItemsQuery'
        - $ref: '#/components/schemas/trendingFacetsQuery'
        - $ref: '#/components/schemas/lookingSimilarQuery'
    processingTimeMS:
      type: integer
      description: Time the server took to process the request, in milliseconds.
      example: 20
    RedirectRuleIndexMetadata:
      type: object
      properties:
        source:
          type: string
          description: Source index for the redirect rule.
        dest:
          type: string
          description: Destination index for the redirect rule.
        reason:
          type: string
          description: Reason for the redirect rule.
        succeed:
          type: boolean
          description: Redirect rule status.
        data:
          title: redirectRuleIndexData
          type: object
          description: Redirect rule data.
          required:
            - ruleObjectID
          properties:
            ruleObjectID:
              type: string
      required:
        - data
        - succeed
        - reason
        - dest
        - source
    baseSearchResponse:
      type: object
      additionalProperties: true
      required:
        - processingTimeMS
      properties:
        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.
        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/en-us/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 didnt, 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.
        appliedRules:
          description: Rules applied to the query.
          title: appliedRules
          type: array
          items:
            type: object
        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:
              min:
                type: number
                format: double
                description: Minimum value in the results.
              max:
                type: number
                format: double
                description: Maximum value in the results.
              avg:
                type: number
                format: double
                description: Average facet 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.
        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'
        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
        _automaticInsights:
          type: boolean
          description: Whether automatic events collection is enabled for the application.
    page:
      type: integer
      description: Page of search results to retrieve.
      default: 0
      minimum: 0
      x-categories:
        - Pagination
    nbHits:
      type: integer
      description: Number of results (hits).
      example: 20
    nbPages:
      type: integer
      description: Number of pages of results.
      example: 1
    hitsPerPage:
      type: integer
      description: Number of hits per page.
      default: 20
      minimum: 1
      maximum: 1000
      x-categories:
        - Pagination
    SearchPagination:
      type: object
      additionalProperties: false
      properties:
        page:
          $ref: '#/components/schemas/page'
        nbHits:
          $ref: '#/components/schemas/nbHits'
        nbPages:
          $ref: '#/components/schemas/nbPages'
        hitsPerPage:
          $ref: '#/components/schemas/hitsPerPage'
    highlightedValue:
      type: string
      description: Highlighted attribute value, including HTML tags.
      example: <em>George</em> <em>Clo</em>oney
    matchLevel:
      type: string
      description: Whether the whole query string matches or only a part.
      enum:
        - none
        - partial
        - full
    highlightResultOption:
      type: object
      description: Surround words that match the query with HTML tags for highlighting.
      additionalProperties: false
      properties:
        value:
          $ref: '#/components/schemas/highlightedValue'
        matchLevel:
          $ref: '#/components/schemas/matchLevel'
        matchedWords:
          type: array
          description: List of matched words from the search query.
          example:
            - action
          items:
            type: string
        fullyHighlighted:
          type: boolean
          description: Whether the entire attribute value is highlighted.
      required:
        - value
        - matchLevel
        - matchedWords
      x-discriminator-fields:
        - matchLevel
        - matchedWords
    highlightResultMap:
      type: object
      description: Surround words that match the query with HTML tags for highlighting.
      x-is-free-form: false
      additionalProperties:
        x-additionalPropertiesName: attribute
        $ref: '#/components/schemas/highlightResult'
    highlightResult:
      oneOf:
        - $ref: '#/components/schemas/highlightResultOption'
        - $ref: '#/components/schemas/highlightResultMap'
        - $ref: '#/components/schemas/highlightResultArray'
    highlightResultArray:
      type: array
      description: Surround words that match the query with HTML tags for highlighting.
      items:
        $ref: '#/components/schemas/highlightResult'
    snippetResultOption:
      type: object
      description: Snippets that show the context around a matching search query.
      additionalProperties: false
      properties:
        value:
          $ref: '#/components/schemas/highlightedValue'
        matchLevel:
          $ref: '#/components/schemas/matchLevel'
      required:
        - value
        - matchLevel
      x-discriminator-fields:
        - matchLevel
    snippetResultMap:
      type: object
      description: Snippets that show the context around a matching search query.
      x-is-free-form: false
      additionalProperties:
        x-additionalPropertiesName: attribute
        $ref: '#/components/schemas/snippetResult'
    snippetResult:
      oneOf:
        - $ref: '#/components/schemas/snippetResultOption'
        - $ref: '#/components/schemas/snippetResultMap'
        - $ref: '#/components/schemas/snippetResultArray'
    snippetResultArray:
      type: array
      description: Snippets that show the context around a matching search query.
      items:
        $ref: '#/components/schemas/snippetResult'
    matchedGeoLocation:
      type: object
      properties:
        lat:
          type: number
          format: double
          description: Latitude of the matched location.
        lng:
          type: number
          format: double
          description: Longitude of the matched location.
        distance:
          type: integer
          description: >-
            Distance between the matched location and the search location (in
            meters).
    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.
    rankingInfo:
      type: object
      description: Object with detailed information about the record's ranking.
      additionalProperties: false
      properties:
        filters:
          type: integer
          minimum: 0
          description: Whether a filter matched the query.
        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).
        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'
        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.
        promoted:
          type: boolean
          description: Whether the record was promoted by a rule.
        proximityDistance:
          type: integer
          minimum: 0
          description: >-
            Number of words between multiple matches in the query plus 1. For
            single word queries, `proximityDistance` is 0.
        userScore:
          type: integer
          description: >-
            Overall ranking of the record, expressed as a single integer. This
            attribute is internal.
        words:
          type: integer
          minimum: 1
          description: Number of matched words.
        promotedByReRanking:
          type: boolean
          description: Whether the record is re-ranked.
      required:
        - nbTypos
        - firstMatchedWord
        - geoDistance
        - nbExactWords
        - userScore
    distinctSeqID:
      type: integer
    recommendScore:
      type: number
      format: double
      minimum: 0
      maximum: 100
      description: Recommendation score.
    recommendHit:
      type: object
      description: Recommend hit.
      additionalProperties: true
      required:
        - objectID
      properties:
        objectID:
          $ref: '#/components/schemas/objectID'
        _highlightResult:
          $ref: '#/components/schemas/highlightResultMap'
        _snippetResult:
          $ref: '#/components/schemas/snippetResultMap'
        _rankingInfo:
          $ref: '#/components/schemas/rankingInfo'
        _distinctSeqID:
          $ref: '#/components/schemas/distinctSeqID'
        _score:
          $ref: '#/components/schemas/recommendScore'
      x-discriminator-fields:
        - objectID
    trendingFacetHit:
      type: object
      description: Trending facet hit.
      required:
        - facetName
        - facetValue
      properties:
        _score:
          $ref: '#/components/schemas/recommendScore'
        facetName:
          $ref: '#/components/schemas/facetName'
        facetValue:
          $ref: '#/components/schemas/facetValue'
      x-discriminator-fields:
        - facetName
        - facetValue
    recommendationsHit:
      oneOf:
        - $ref: '#/components/schemas/recommendHit'
        - $ref: '#/components/schemas/trendingFacetHit'
    recommendationsHits:
      type: object
      additionalProperties: false
      properties:
        hits:
          type: array
          items:
            $ref: '#/components/schemas/recommendationsHit'
      required:
        - hits
    recommendationsResults:
      allOf:
        - $ref: '#/components/schemas/baseSearchResponse'
        - $ref: '#/components/schemas/SearchPagination'
        - $ref: '#/components/schemas/recommendationsHits'
    recommendModels:
      type: string
      enum:
        - related-products
        - bought-together
        - trending-facets
        - trending-items
    updatedAt:
      type: string
      example: '2023-07-04T12:49:15Z'
      description: Date and time when the object was updated, in RFC 3339 format.
    ruleID:
      title: objectID
      type: string
      description: Unique identifier of a rule object.
    context:
      type: string
      pattern: '[A-Za-z0-9_-]+'
      description: >
        An additional restriction that only triggers the rule, when the search
        has the same value as `ruleContexts` parameter.

        For example, if `context: mobile`, the rule is only triggered when the
        search request has a matching `ruleContexts: mobile`.

        A rule context must only contain alphanumeric characters.
      example: mobile
    Condition:
      type: object
      description: |
        Condition that triggers the rule.
        If not specified, the rule is triggered for all recommendations.
      properties:
        filters:
          $ref: '#/components/schemas/filters'
        context:
          $ref: '#/components/schemas/context'
    HideConsequenceObject:
      type: object
      description: Object ID of the recommendation you want to exclude.
      properties:
        objectID:
          $ref: '#/components/schemas/objectID'
    HideConsequence:
      type: array
      description: Exclude items from recommendations.
      minItems: 1
      items:
        $ref: '#/components/schemas/HideConsequenceObject'
    PromoteConsequenceObject:
      type: object
      description: Object ID and position of the recommendation you want to pin.
      properties:
        objectID:
          $ref: '#/components/schemas/objectID'
        position:
          type: integer
          description: Index in the list of recommendations where to place this item.
          minimum: 0
    PromoteConsequence:
      type: array
      description: Place items at specific positions in the list of recommendations.
      minItems: 1
      items:
        $ref: '#/components/schemas/PromoteConsequenceObject'
    AutoFacetFilter:
      type: object
      description: >-
        Facet attribute. Only recommendations with the same value (or only
        recommendations with a different value) as the original viewed item are
        included.
      properties:
        facet:
          type: string
          description: Facet attribute.
        negative:
          type: boolean
          description: >
            Whether the filter is negative.

            If true, recommendations must not have the same value for the
            `facet` attribute.

            If false, recommendations must have the same value for the `facet`
            attribute.
    ParamsConsequence:
      type: object
      description: Filter or boost recommendations matching a facet filter.
      properties:
        automaticFacetFilters:
          type: array
          description: >-
            Filter recommendations that match or don't match the same
            `facet:facet_value` combination as the viewed item.
          items:
            $ref: '#/components/schemas/AutoFacetFilter'
        filters:
          $ref: '#/components/schemas/filters'
        optionalFilters:
          type: array
          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.

            Matches with higher weights (`<score=N>`) rank before matches with
            lower weights.

            If you're using a negative filter `facet:-value`, matching records
            rank after records that don't match.
          items:
            type: string
          example:
            - category:books<score=1>
            - category:-movies<score=1>
    Consequence:
      type: object
      description: Effect of the rule.
      properties:
        hide:
          $ref: '#/components/schemas/HideConsequence'
        promote:
          $ref: '#/components/schemas/PromoteConsequence'
        params:
          $ref: '#/components/schemas/ParamsConsequence'
    timeRange:
      type: object
      additionalProperties: false
      properties:
        from:
          type: integer
          format: int64
          description: When the rule should start to be active, in Unix epoch time.
        until:
          type: integer
          format: int64
          description: When the rule should stop to be active, in Unix epoch time.
      required:
        - from
        - until
    RecommendRule:
      type: object
      description: Recommend rule.
      additionalProperties: false
      properties:
        _metadata:
          title: ruleMetadata
          type: object
          description: Rule metadata.
          properties:
            lastUpdate:
              $ref: '#/components/schemas/updatedAt'
        objectID:
          $ref: '#/components/schemas/ruleID'
        condition:
          $ref: '#/components/schemas/Condition'
        consequence:
          $ref: '#/components/schemas/Consequence'
        description:
          type: string
          description: >-
            Description of the rule's purpose. This can be helpful for display
            in the Algolia dashboard.
          example: Boost on-sale items
        enabled:
          type: boolean
          default: true
          description: >-
            Indicates whether to enable the rule. If it isn't enabled, it isn't
            applied at query time.
        validity:
          type: array
          description: Time periods when the rule is active.
          items:
            $ref: '#/components/schemas/timeRange'
    taskID:
      type: integer
      format: int64
      example: 1514562690001
      description: >
        Unique identifier of a task.


        A successful API response means that a task was added to a queue. It
        might not run immediately. You can check the task's progress with the
        [`task` operation](#tag/Indices/operation/getTask) and this `taskID`.
    deletedAt:
      type: string
      example: '2023-06-27T14:42:38.831Z'
      description: Date and time when the object was deleted, in RFC 3339 format.
    taskStatus:
      type: string
      enum:
        - published
        - notPublished
      description: >-
        Task status, `published` if the task is completed, `notPublished`
        otherwise.
    parameters_query:
      type: string
      description: Search query.
      default: ''
    parameters_page:
      type: integer
      minimum: 0
      description: >
        Requested page of the API response.


        Algolia uses `page` and `hitsPerPage` to control how search results are
        displayed
        ([paginated](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/)).


        - `hitsPerPage`: sets the number of search results (_hits_) displayed
        per page.

        - `page`: specifies the page number of the search results you want to
        retrieve. Page numbering starts at 0, so the first page is `page=0`, the
        second is `page=1`, and so on.


        For example, to display 10 results per page starting from the third
        page, set `hitsPerPage` to 10 and `page` to 2.
    parameters_hitsPerPage:
      type: integer
      default: 20
      minimum: 1
      maximum: 1000
      description: >
        Maximum number of hits per page.


        Algolia uses `page` and `hitsPerPage` to control how search results are
        displayed
        ([paginated](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/)).


        - `hitsPerPage`: sets the number of search results (_hits_) displayed
        per page.

        - `page`: specifies the page number of the search results you want to
        retrieve. Page numbering starts at 0, so the first page is `page=0`, the
        second is `page=1`, and so on.


        For example, to display 10 results per page starting from the third
        page, set `hitsPerPage` to 10 and `page` to 2.
    recommendUpdatedAtResponse:
      type: object
      description: Response, taskID, and update timestamp.
      additionalProperties: false
      required:
        - taskID
        - updatedAt
      properties:
        taskID:
          $ref: '#/components/schemas/taskID'
        updatedAt:
          $ref: '#/components/schemas/updatedAt'
  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'
    DeletedAt:
      description: OK
      content:
        application/json:
          schema:
            title: deletedAtResponse
            description: Response, taskID, and deletion timestamp.
            additionalProperties: false
            type: object
            required:
              - taskID
              - deletedAt
            properties:
              taskID:
                $ref: '#/components/schemas/taskID'
              deletedAt:
                $ref: '#/components/schemas/deletedAt'
    RecommendUpdatedAt:
      description: OK
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/recommendUpdatedAtResponse'
x-tagGroups:
  - name: Recommend
    tags:
      - recommendations
      - rules
