@graphcommerce/algolia-recommend 9.0.0-canary.84

package/algolia-recommend-spec.yaml

@@ -0,0 +1,2720 @@
+openapi: 3.0.2
+info:
+  title: Recommend API
+  description: >
+    The Recommend API lets you retrieve recommendations from one of Algolia's AI recommendation models that you previously trained on your data.
+    
+    
+    ## Client libraries
+    
+    
+    Use Algolia's API clients and libraries to reliably integrate Algolia's APIs with your apps.
+    
+    The official API clients are covered by Algolia's [Service Level Agreement](https://www.algolia.com/policies/sla/).
+    
+    
+    See: [Algolia's ecosystem](https://www.algolia.com/doc/guides/getting-started/how-algolia-works/in-depth/ecosystem/)
+    
+    
+    ## Base URLs
+    
+    
+    The base URLs for requests to the Recommend API are:
+    
+    
+    - `https://{APPLICATION_ID}.algolia.net`
+    
+    - `https://{APPLICATION_ID}-dsn.algolia.net`.
+      If your subscription includes a [Distributed Search Network](https://dashboard.algolia.com/infra),
+      this ensures that requests are sent to servers closest to users.
+    
+    Both URLs provide high availability by distributing requests with load balancing.
+    
+    
+    **All requests must use HTTPS.**
+    
+    
+    ## Retry strategy
+    
+    
+    To guarantee a high availability, implement a retry strategy for all API requests using the URLs of your servers as fallbacks:
+    
+    
+    - `https://{APPLICATION_ID}-1.algolianet.com`
+    
+    - `https://{APPLICATION_ID}-2.algolianet.com`
+    
+    - `https://{APPLICATION_ID}-3.algolianet.com`
+    
+    
+    These URLs use a different DNS provider than the primary URLs.
+    
+    You should randomize this list to ensure an even load across the three servers.
+    
+    
+    All Algolia API clients implement this retry strategy.
+    
+    
+    ## Authentication
+    
+    
+    To authenticate your API requests, add these headers:
+    
+    
+    - `x-algolia-application-id`. Your Algolia application ID.
+    
+    - `x-algolia-api-key`. An API key with the necessary permissions to make the request.
+      The required access control list (ACL) to make a request is listed in each endpoint's reference.
+    
+    You can find your application ID and API key in the [Algolia dashboard](https://dashboard.algolia.com/account).
+    
+    
+    ## Request format
+    
+    
+    Request bodies must be JSON objects.
+    
+    
+    ## Response status and errors
+    
+    
+    The Recommend API returns JSON responses.
+    
+    Since JSON doesn't guarantee any specific ordering, don't rely on the order of attributes in the API response.
+    
+    
+    Successful responses return a `2xx` status. Client errors return a `4xx` status. Server errors are indicated by a `5xx` status.
+    
+    Error responses have a `message` property with more information.
+    
+    
+    ## Version
+    
+    
+    The current version of the Recommend API is version 1, as indicated by the `/1/` in each endpoint's URL.
+
+  version: 1.0.0
+paths:
+  /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'
+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: YourIndexName
+    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).
+    query:
+      type: string
+      description: Search query.
+      x-categories:
+        - Search
+    searchParamsQuery:
+      type: object
+      additionalProperties: false
+      properties:
+        query:
+          $ref: '#/components/schemas/query'
+    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`.
+
+      x-categories:
+        - Filtering
+      type: object
+    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 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: `<`, `<=`, `=`, `!=`, `>`, `>=`. Comparsions 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
+    page:
+      type: integer
+      description: Page of search results to retrieve.
+      minimum: 0
+      x-categories:
+        - Pagination
+    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 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
+      x-categories:
+        - Geo-Search
+    aroundLatLngViaIP:
+      type: boolean
+      description: Whether to obtain the coordinates from the request's IP address.
+      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
+    insideBoundingBox:
+      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
+    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
+    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
+    baseSearchParamsWithoutQuery:
+      type: object
+      additionalProperties: false
+      properties:
+        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.
+
+          example: comedy drama crime Macy Buscemi
+          x-categories:
+            - Search
+        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:
+          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).
+
+          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.
+          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: []
+          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`.
+
+          x-categories:
+            - Faceting
+        page:
+          $ref: '#/components/schemas/page'
+        offset:
+          type: integer
+          description: Position of the first hit to retrieve.
+          x-categories:
+            - Pagination
+        length:
+          type: integer
+          description: Number of hits to retrieve (used in combination with `offset`).
+          minimum: 0
+          maximum: 1000
+          x-categories:
+            - Pagination
+        aroundLatLng:
+          $ref: '#/components/schemas/aroundLatLng'
+        aroundLatLngViaIP:
+          $ref: '#/components/schemas/aroundLatLngViaIP'
+        aroundRadius:
+          $ref: '#/components/schemas/aroundRadius'
+        aroundPrecision:
+          $ref: '#/components/schemas/aroundPrecision'
+        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
+        insideBoundingBox:
+          $ref: '#/components/schemas/insideBoundingBox'
+        insidePolygon:
+          $ref: '#/components/schemas/insidePolygon'
+        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`.
+
+          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.
+
+          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).
+
+          minimum: 0
+          maximum: 100
+          x-categories:
+            - Personalization
+        userToken:
+          $ref: '#/components/schemas/userToken'
+        getRankingInfo:
+          type: boolean
+          description: >-
+            Whether the search response should include detailed ranking information.
+
+          x-categories:
+            - Advanced
+        synonyms:
+          type: boolean
+          description: Whether to take into account an index's synonyms for this search.
+          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/).
+
+          x-categories:
+            - Analytics
+        analytics:
+          type: boolean
+          description: Whether this search will be included in Analytics.
+          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/).
+
+          x-categories:
+            - Analytics
+        percentileComputation:
+          type: boolean
+          description: >-
+            Whether to include this search when calculating processing-time percentiles.
+
+          x-categories:
+            - Advanced
+        enableABTest:
+          type: boolean
+          description: Whether to enable A/B testing for this search.
+          x-categories:
+            - Advanced
+    baseSearchParams:
+      allOf:
+        - $ref: '#/components/schemas/searchParamsQuery'
+        - $ref: '#/components/schemas/baseSearchParamsWithoutQuery'
+    hitsPerPage:
+      type: integer
+      description: Number of hits per page.
+      minimum: 1
+      maximum: 1000
+      x-categories:
+        - Pagination
+    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 concetenation](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/splitting-and-concatenation/) is 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
+    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
+    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 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/).
+
+      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/).
+
+      x-categories:
+        - Query strategy
+    mode:
+      type: string
+      enum:
+        - neuralSearch
+        - keywordSearch
+      description: >
+        Search mode the index will use to query for results.
+        
+        
+        This setting only applies to indices, for which Algolia enabled NeuralSearch for you.
+
+      x-categories:
+        - Query strategy
+    semanticSearch:
+      type: object
+      description: |
+        Settings for the semantic search part of NeuralSearch.
+        Only used when `mode` is `neuralSearch`.
+      properties:
+        eventSources:
+          oneOf:
+            - type: array
+              description: |
+                Indices from which to collect click and conversion events.
+
+                If null, the current index and all its replicas are used.
+              items:
+                type: string
+            - type: 'null'
+    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.
+
+      x-categories:
+        - Query strategy
+    alternativesAsExact:
+      type: string
+      enum:
+        - ignorePlurals
+        - singleWordSynonym
+        - multiWordsSynonym
+      x-categories:
+        - Query strategy
+    advancedSyntaxFeatures:
+      type: string
+      enum:
+        - 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
+    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
+      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
+    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/facets'
+        values:
+          $ref: '#/components/schemas/values'
+    redirectURL:
+      description: The redirect rule container.
+      type: object
+      additionalProperties: false
+      properties:
+        url:
+          type: string
+    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'
+      x-categories:
+        - Advanced
+    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
+    indexSettingsAsSearchParams:
+      type: object
+      additionalProperties: false
+      properties:
+        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.
+
+          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/).
+
+          x-categories:
+            - Ranking
+        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.
+
+          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.
+
+          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.
+
+          x-categories:
+            - Highlighting and Snippeting
+        highlightPreTag:
+          type: string
+          description: >-
+            HTML tag to insert before the highlighted parts in all highlighted results and snippets.
+
+          x-categories:
+            - Highlighting and Snippeting
+        highlightPostTag:
+          type: string
+          description: >-
+            HTML tag to insert after the highlighted parts in all highlighted results and snippets.
+
+          x-categories:
+            - Highlighting and Snippeting
+        snippetEllipsisText:
+          type: string
+          description: String used as an ellipsis indicator when a snippet is truncated.
+          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.
+
+          x-categories:
+            - Highlighting and Snippeting
+        hitsPerPage:
+          $ref: '#/components/schemas/hitsPerPage'
+        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).
+
+          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).
+
+          x-categories:
+            - Typos
+        typoTolerance:
+          $ref: '#/components/schemas/typoTolerance'
+        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.
+          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.
+
+          x-categories:
+            - Typos
+        ignorePlurals:
+          $ref: '#/components/schemas/ignorePlurals'
+        removeStopWords:
+          $ref: '#/components/schemas/removeStopWords'
+        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.
+          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/).
+
+          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).
+
+          x-categories:
+            - Languages
+        enableRules:
+          type: boolean
+          description: Whether to enable rules.
+          x-categories:
+            - Rules
+        enablePersonalization:
+          type: boolean
+          description: Whether to enable Personalization.
+          x-categories:
+            - Personalization
+        queryType:
+          $ref: '#/components/schemas/queryType'
+        removeWordsIfNoResults:
+          $ref: '#/components/schemas/removeWordsIfNoResults'
+        mode:
+          $ref: '#/components/schemas/mode'
+        semanticSearch:
+          $ref: '#/components/schemas/semanticSearch'
+        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.
+
+          x-categories:
+            - Query strategy
+        optionalWords:
+          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 dividied 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).
+
+          x-categories:
+            - Query strategy
+        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 likelyhood 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.
+
+          x-categories:
+            - Query strategy
+        exactOnSingleWordQuery:
+          $ref: '#/components/schemas/exactOnSingleWordQuery'
+        alternativesAsExact:
+          type: array
+          items:
+            $ref: '#/components/schemas/alternativesAsExact'
+          description: >
+            Alternatives of query words that should be considered as exact matches by the Exact ranking criterion.
+            
+            
+            - `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.
+
+          x-categories:
+            - Query strategy
+        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.
+          x-categories:
+            - Query strategy
+        distinct:
+          $ref: '#/components/schemas/distinct'
+        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 occurences of "house" are replaced by "home" in the highlighted response.
+
+          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.
+
+          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 attributes should be included.
+            
+            
+            You can't exclude these properties:
+            
+            `message`, `warning`, `cursor`, `serverUsed`, `indexUsed`,
+            
+            `abTestVariantID`, `parsedQuery`, or any property triggered by the `getRankingInfo` parameter.
+            
+            
+            Don't exclude properties that you might need in your search UI.
+
+          x-categories:
+            - Advanced
+        maxFacetHits:
+          $ref: '#/components/schemas/maxFacetHits'
+        maxValuesPerFacet:
+          type: integer
+          description: Maximum number of facet values to return for each facet.
+          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/).
+
+          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.
+
+          x-categories:
+            - Advanced
+        renderingContent:
+          $ref: '#/components/schemas/renderingContent'
+        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.
+
+          x-categories:
+            - Filtering
+        reRankingApplyFilter:
+          oneOf:
+            - $ref: '#/components/schemas/reRankingApplyFilter'
+            - type: 'null'
+    searchParamsObject:
+      title: Search parameters as object
+      description: >-
+        Each parameter value, including the `query` must not be larger than 512 bytes.
+
+      allOf:
+        - $ref: '#/components/schemas/baseSearchParams'
+        - $ref: '#/components/schemas/indexSettingsAsSearchParams'
+    searchParams:
+      title: queryParameters
+      allOf:
+        - $ref: '#/components/schemas/searchParamsObject'
+    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
+          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/searchParamsObject'
+      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/searchParamsObject'
+    relatedProducts:
+      type: object
+      properties:
+        model:
+          $ref: '#/components/schemas/relatedModel'
+        objectID:
+          $ref: '#/components/schemas/objectID'
+        fallbackParameters:
+          $ref: '#/components/schemas/searchParamsObject'
+      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/searchParamsObject'
+      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:
+          description: Facet attribute for which to retrieve trending facet values.
+        model:
+          $ref: '#/components/schemas/trendingFacetsModel'
+        fallbackParameters:
+          $ref: '#/components/schemas/searchParamsObject'
+      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/searchParamsObject'
+      required:
+        - model
+        - objectID
+    lookingSimilarQuery:
+      title: Looking similar
+      allOf:
+        - $ref: '#/components/schemas/baseRecommendRequest'
+        - $ref: '#/components/schemas/lookingSimilar'
+    recommendedForYouModel:
+      type: string
+      description: |
+        "Recommened for you" model.
+      enum:
+        - recommended-for-you
+    recommendedForYou:
+      type: object
+      properties:
+        model:
+          $ref: '#/components/schemas/recommendedForYouModel'
+        fallbackParameters:
+          $ref: '#/components/schemas/searchParamsObject'
+      required:
+        - model
+    recommendedForYouQuery:
+      title: Recommended for you
+      allOf:
+        - $ref: '#/components/schemas/baseRecommendRequest'
+        - $ref: '#/components/schemas/recommendedForYou'
+    recommendationsRequest:
+      oneOf:
+        - $ref: '#/components/schemas/boughtTogetherQuery'
+        - $ref: '#/components/schemas/relatedQuery'
+        - $ref: '#/components/schemas/trendingItemsQuery'
+        - $ref: '#/components/schemas/trendingFacetsQuery'
+        - $ref: '#/components/schemas/lookingSimilarQuery'
+        - $ref: '#/components/schemas/recommendedForYouQuery'
+    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
+    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.
+      x-categories:
+        - Advanced
+    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 didn’t, in the end, impact the exhaustivity of the query.
+
+            rulesMatch:
+              type: boolean
+              title: rulesMatch
+              description: >-
+                Rules matching exhaustivity. The value is `false` if rules were enable for this query, and could not be fully processed due a timeout. This is generally caused by the number of alternatives (such as typos) which is too large.
+
+            typo:
+              type: boolean
+              title: typo
+              description: >-
+                Whether the typo search was exhaustive (`true`) or approximate (`false`). An approximation is done when the typo search query part takes more than 10% of the query budget (ie. 5ms by default) to be processed (this can happen when a lot of typo alternatives exist for the query). This field will not be included when typo-tolerance is entirely disabled.
+
+        exhaustiveFacetsCount:
+          type: boolean
+          description: >-
+            See the `facetsCount` field of the `exhaustive` object in the response.
+
+          deprecated: true
+        exhaustiveNbHits:
+          type: boolean
+          description: See the `nbHits` field of the `exhaustive` object in the response.
+          deprecated: true
+        exhaustiveTypo:
+          type: boolean
+          description: See the `typo` field of the `exhaustive` object in the response.
+          deprecated: true
+        facets:
+          title: facets
+          type: object
+          additionalProperties:
+            x-additionalPropertiesName: facet
+            type: object
+            additionalProperties:
+              x-additionalPropertiesName: facet count
+              type: integer
+          description: Facet counts.
+        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.
+    nbHits:
+      type: integer
+      description: Number of results (hits).
+      example: 20
+    nbPages:
+      type: integer
+      description: Number of pages of results.
+      example: 1
+    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'
+      required:
+        - page
+        - nbHits
+        - nbPages
+        - hitsPerPage
+    highlightResultMap:
+      type: object
+      description: Surround words that match the query with HTML tags for highlighting.
+      additionalProperties:
+        x-additionalPropertiesName: attribute
+        $ref: '#/components/schemas/highlightResult'
+    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
+    highlightResultOptionMap:
+      type: object
+      description: Surround words that match the query with HTML tags for highlighting.
+      additionalProperties:
+        x-additionalPropertiesName: attribute
+        $ref: '#/components/schemas/highlightResultOption'
+    highlightResultOptionArray:
+      type: array
+      description: Surround words that match the query with HTML tags for highlighting.
+      items:
+        $ref: '#/components/schemas/highlightResultOption'
+    highlightResult:
+      oneOf:
+        - $ref: '#/components/schemas/highlightResultMap'
+        - $ref: '#/components/schemas/highlightResultOption'
+        - $ref: '#/components/schemas/highlightResultOptionMap'
+        - $ref: '#/components/schemas/highlightResultOptionArray'
+    snippetResultMap:
+      type: object
+      description: Snippets that show the context around a matching search query.
+      additionalProperties:
+        x-additionalPropertiesName: attribute
+        $ref: '#/components/schemas/snippetResult'
+    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
+    snippetResultOptionMap:
+      type: object
+      description: Snippets that show the context around a matching search query.
+      additionalProperties:
+        x-additionalPropertiesName: attribute
+        $ref: '#/components/schemas/snippetResultOption'
+    snippetResultOptionArray:
+      type: array
+      description: Snippets that show the context around a matching search query.
+      items:
+        $ref: '#/components/schemas/snippetResultOption'
+    snippetResult:
+      oneOf:
+        - $ref: '#/components/schemas/snippetResultMap'
+        - $ref: '#/components/schemas/snippetResultOption'
+        - $ref: '#/components/schemas/snippetResultOptionMap'
+        - $ref: '#/components/schemas/snippetResultOptionArray'
+    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
+        - _score
+      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'
+    trendingFacetHit:
+      type: object
+      description: Trending facet hit.
+      required:
+        - _score
+        - facetName
+        - facetValue
+      properties:
+        _score:
+          $ref: '#/components/schemas/recommendScore'
+        facetName:
+          $ref: '#/components/schemas/facetName'
+        facetValue:
+          $ref: '#/components/schemas/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'
+    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: Display a promotional banner
+        enabled:
+          type: boolean
+          description: >-
+            Indicates whether to enable the rule. If it isn't enabled, it isn't applied at query time.
+
+    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.
+    parameters_page:
+      type: integer
+      minimum: 0
+      description: Requested page of the API response.
+    parameters_hitsPerPage:
+      type: integer
+      minimum: 1
+      maximum: 1000
+      description: Maximum number of hits per page.
+  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'