@graphcommerce/algolia-products 9.0.0-canary.100

package/algolia-spec.yaml

@@ -0,0 +1,4418 @@
+openapi: 3.0.2
+info:
+  title: Search API
+  description: >
+    The Algolia Search API lets you search, configure, and mange your indices and records.
+    
+    
+    ## 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 Search 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
+    
+    
+    Depending on the endpoint, request bodies are either JSON objects or arrays of JSON objects,
+    
+    
+    ## Parameters
+    
+    
+    Parameters are passed as query parameters for GET and DELETE requests,
+    
+    and in the request body for POST and PUT requests.
+    
+    
+    Query parameters must be [URL-encoded](https://developer.mozilla.org/en-US/docs/Glossary/Percent-encoding).
+    
+    Non-ASCII characters must be UTF-8 encoded.
+    
+    Plus characters (`+`) are interpreted as spaces.
+    
+    Arrays as query parameters must be one of:
+    
+    
+    - A comma-separated string: `attributesToRetrieve=title,description`
+    
+    - A URL-encoded JSON array: `attributesToRetrieve=%5B%22title%22,%22description%22%D`
+    
+    
+    ## Response status and errors
+    
+    
+    The Search API returns JSON responses.
+    
+    Since JSON doesn't guarantee any specific ordering, don't rely on the order of attributes in the API response.
+    
+    
+    Successful responses return 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 Search API is version 1, as indicated by the `/1/` in each endpoint's URL.
+
+  version: 1.0.0
+servers:
+  - url: https://{appId}.algolia.net
+    variables:
+      appId:
+        default: myAppId
+  - url: https://{appId}-1.algolianet.com
+    variables:
+      appId:
+        default: myAppId
+  - url: https://{appId}-2.algolianet.com
+    variables:
+      appId:
+        default: myAppId
+  - url: https://{appId}-3.algolianet.com
+    variables:
+      appId:
+        default: myAppId
+  - url: https://{appId}-dsn.algolia.net
+    variables:
+      appId:
+        default: myAppId
+security:
+  - appId: []
+    apiKey: []
+tags:
+  - name: Advanced
+    description: Query your logs.
+  - name: Api Keys
+    x-displayName: API keys
+    description: >
+      Manage your API keys.
+      
+      
+      API requests must be authenticated with an API key.
+      
+      API keys can have permissions (access control lists, ACL) and restrictions.
+
+    externalDocs:
+      url: https://www.algolia.com/doc/guides/security/api-keys/
+      description: |
+        Related guide: API keys.
+  - name: Clusters
+    description: |
+      Multi-cluster operations.
+
+      Algolia no longer offers multi-cluster management.
+    externalDocs:
+      url: >-
+        https://www.algolia.com/doc/guides/scaling/managing-multiple-clusters-mcm/
+
+      description: |
+        Related guide: Multi-cluster management.
+  - name: Dictionaries
+    description: >
+      Manage your dictionaries.
+      
+      
+      Customize language-specific settings, such as stop words, plurals, or word segmentation.
+      
+      
+      Dictionaries are application-wide.
+
+    externalDocs:
+      url: >-
+        https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/
+
+      description: |
+        Related guide: Natural languages.
+  - name: Indices
+    description: >
+      Manage your indices and index settings.
+      
+      
+      Indices are copies of your data that are stored on Algolia's servers.
+      
+      They're optimal data structures for fast search and are made up of records and settings.
+
+    externalDocs:
+      url: >-
+        https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/
+
+      description: |
+        Related guide: Manage your indices.
+  - name: Records
+    description: >
+      Add, update, and delete records from your indices.
+      
+      
+      Records are individual items in your index.
+      
+      When they match a search query, they're returned as search results, in the order determined by your ranking.
+      
+      Records are schemaless JSON objects.
+
+    externalDocs:
+      url: >-
+        https://www.algolia.com/doc/guides/sending-and-managing-data/prepare-your-data/
+
+      description: |
+        Related guide: Prepare your records.
+  - name: Rules
+    description: >
+      Create, update, delete, and search for rules.
+      
+      
+      Rules are _if-then_ statements that you can use to curate search results.
+      
+      Rules have _conditions_ which can trigger _consequences_.
+      
+      Consequences are changes to the search results, such as changing the order of search results, or boosting a facet.
+      
+      This can be useful for tuning specific queries or for merchandising.
+
+    externalDocs:
+      url: >-
+        https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/
+
+      description: |
+        Related guide: Rules.
+  - name: Search
+    description: Search one or more indices for matching records or facet values.
+  - name: Synonyms
+    description: |
+      Create, update, delete, and search for synonyms.
+
+      Synonyms are terms that the search engine should consider equal.
+    externalDocs:
+      url: >-
+        https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/
+
+      description: |
+        Related guide: Synonyms.
+  - name: Vaults
+    description: >-
+      Algolia Vault lets you restrict access to your clusters to specific IP addresses and provides disk-level encryption at rest.
+
+    externalDocs:
+      url: https://www.algolia.com/doc/guides/security/algolia-vault/
+      description: |
+        Related guide: Algolia Vault.
+  - name: _model_index_settings
+    x-displayName: Index settings
+    description: |
+      <SchemaDefinition schemaRef="#/components/schemas/indexSettings" />.
+paths:
+  /1/indexes/{indexName}/query:
+    post:
+      tags:
+        - search
+      operationId: searchSingleIndex
+      x-use-read-transporter: true
+      x-cacheable: true
+      x-acl:
+        - search
+      summary: Search an index
+      description: >
+        Searches a single index and return matching search results (_hits_).
+        
+        
+        This method lets you retrieve up to 1,000 hits.
+        
+        If you need more, use the [`browse` operation](#tag/Search/operation/browse) or increase the `paginatedLimitedTo` index setting.
+
+      parameters:
+        - $ref: '#/components/parameters/IndexName'
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/searchParams'
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/searchResponse'
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '402':
+          $ref: '#/components/responses/FeatureNotEnabled'
+        '403':
+          $ref: '#/components/responses/MethodNotAllowed'
+        '404':
+          $ref: '#/components/responses/IndexNotFound'
+  /1/indexes/{indexName}/facets/{facetName}/query:
+    post:
+      tags:
+        - search
+      operationId: searchForFacetValues
+      x-use-read-transporter: true
+      x-cacheable: true
+      x-acl:
+        - search
+      summary: Search for facet values
+      description: >
+        Searches for values of a specified facet attribute.
+        
+        
+        - By default, facet values are sorted by decreasing count.
+          You can adjust this with the `sortFacetValueBy` parameter.
+        - Searching for facet values doesn't work if you have **more than 65 searchable facets and searchable attributes combined**.
+
+      parameters:
+        - $ref: '#/components/parameters/IndexName'
+        - name: facetName
+          description: >
+            Facet attribute in which to search for values.
+            
+            
+            This attribute must be included in the `attributesForFaceting` index setting with the `searchable()` modifier.
+
+          in: path
+          required: true
+          schema:
+            type: string
+      requestBody:
+        content:
+          application/json:
+            schema:
+              title: searchForFacetValuesRequest
+              type: object
+              additionalProperties: false
+              properties:
+                params:
+                  $ref: '#/components/schemas/paramsAsString'
+                facetQuery:
+                  $ref: '#/components/schemas/facetQuery'
+                maxFacetHits:
+                  $ref: '#/components/schemas/maxFacetHits'
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/searchForFacetValuesResponse'
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '402':
+          $ref: '#/components/responses/FeatureNotEnabled'
+        '403':
+          $ref: '#/components/responses/MethodNotAllowed'
+        '404':
+          $ref: '#/components/responses/IndexNotFound'
+  /1/indexes/{indexName}/settings:
+    get:
+      tags:
+        - search
+      operationId: getSettings
+      x-acl:
+        - search
+      description: Retrieves an object with non-null index settings.
+      summary: Retrieve index settings
+      parameters:
+        - $ref: '#/components/parameters/IndexName'
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/settingsResponse'
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '402':
+          $ref: '#/components/responses/FeatureNotEnabled'
+        '403':
+          $ref: '#/components/responses/MethodNotAllowed'
+        '404':
+          $ref: '#/components/responses/IndexNotFound'
+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.
+
+  schemas:
+    attributeToUpdate:
+      x-keep-model: true
+      deprecated: true
+      oneOf:
+        - type: string
+        - $ref: '#/components/schemas/builtInOperation'
+    ErrorBase:
+      description: Error.
+      type: object
+      x-keep-model: true
+      additionalProperties: true
+      properties:
+        message:
+          type: string
+          example: Invalid Application-Id or API-Key
+    paramsAsString:
+      description: Search parameters as a URL-encoded query string.
+      example: hitsPerPage=2&getRankingInfo=1
+      type: string
+    searchParamsString:
+      type: object
+      title: Search parameters as query string.
+      description: Search parameters as query string.
+      additionalProperties: false
+      x-discriminator-fields:
+        - params
+      properties:
+        params:
+          $ref: '#/components/schemas/paramsAsString'
+    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:
+      $ref: '#/components/schemas/searchParamsObject'
+    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
+    objectID:
+      type: string
+      description: Unique record identifier.
+      example: test-record-123
+    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
+    hit:
+      type: object
+      description: >
+        Search result.
+        
+        
+        A hit is a record from your index, augmented with special attributes for highlighting, snippeting, and ranking.
+
+      x-is-generic: true
+      additionalProperties: true
+      required:
+        - objectID
+      properties:
+        objectID:
+          $ref: '#/components/schemas/objectID'
+        _highlightResult:
+          $ref: '#/components/schemas/highlightResultMap'
+        _snippetResult:
+          $ref: '#/components/schemas/snippetResultMap'
+        _rankingInfo:
+          $ref: '#/components/schemas/rankingInfo'
+        _distinctSeqID:
+          $ref: '#/components/schemas/distinctSeqID'
+    searchHits:
+      type: object
+      additionalProperties: true
+      properties:
+        hits:
+          type: array
+          description: >
+            Search results (hits).
+            
+            
+            Hits are records from your index that match the search criteria, augmented with additional attributes, such as, for highlighting.
+
+          items:
+            $ref: '#/components/schemas/hit'
+        query:
+          $ref: '#/components/schemas/query'
+        params:
+          type: string
+          description: URL-encoded string of all search parameters.
+          example: query=a&hitsPerPage=20
+      required:
+        - hits
+        - query
+        - params
+    searchResponse:
+      additionalProperties: true
+      allOf:
+        - $ref: '#/components/schemas/baseSearchResponse'
+        - $ref: '#/components/schemas/SearchPagination'
+        - $ref: '#/components/schemas/searchHits'
+    indexName:
+      type: string
+      example: products
+      description: Index name (case-sensitive).
+    searchTypeDefault:
+      type: string
+      enum:
+        - default
+      description: >
+        - `default`: perform a search query
+        
+        - `facet` [searches for facet values](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#search-for-facet-values).
+
+    searchForHitsOptions:
+      x-is-SearchForHitsOptions: true
+      type: object
+      properties:
+        indexName:
+          $ref: '#/components/schemas/indexName'
+        type:
+          $ref: '#/components/schemas/searchTypeDefault'
+      required:
+        - indexName
+    SearchForHits:
+      allOf:
+        - $ref: '#/components/schemas/searchParams'
+        - $ref: '#/components/schemas/searchForHitsOptions'
+    facetQuery:
+      type: string
+      description: Text to search inside the facet's values.
+      example: george
+    searchTypeFacet:
+      type: string
+      enum:
+        - facet
+      description: >
+        - `default`: perform a search query
+        
+        - `facet` [searches for facet values](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#search-for-facet-values).
+
+    searchForFacetsOptions:
+      type: object
+      properties:
+        facet:
+          type: string
+          description: Facet name.
+        indexName:
+          $ref: '#/components/schemas/indexName'
+        facetQuery:
+          $ref: '#/components/schemas/facetQuery'
+        maxFacetHits:
+          $ref: '#/components/schemas/maxFacetHits'
+        type:
+          $ref: '#/components/schemas/searchTypeFacet'
+      required:
+        - indexName
+        - type
+        - facet
+    SearchForFacets:
+      allOf:
+        - $ref: '#/components/schemas/searchParams'
+        - $ref: '#/components/schemas/searchForFacetsOptions'
+      x-discriminator-fields:
+        - facet
+        - type
+    SearchQuery:
+      oneOf:
+        - $ref: '#/components/schemas/SearchForHits'
+        - $ref: '#/components/schemas/SearchForFacets'
+    searchStrategy:
+      type: string
+      enum:
+        - none
+        - stopIfEnoughMatches
+      description: >
+        Strategy for multiple search queries:
+        
+        
+        - `none`. Run all queries.
+        
+        - `stopIfEnoughMatches`. Run the queries one by one, stopping as soon as a query matches at least the `hitsPerPage` number of results.
+
+    searchForFacetValuesResponse:
+      type: object
+      additionalProperties: false
+      required:
+        - facetHits
+        - exhaustiveFacetsCount
+      x-discriminator-fields:
+        - facetHits
+      properties:
+        facetHits:
+          type: array
+          description: Matching facet values.
+          items:
+            title: facetHits
+            type: object
+            additionalProperties: false
+            required:
+              - value
+              - highlighted
+              - count
+            properties:
+              value:
+                description: Facet value.
+                example: Mobile phone
+                type: string
+              highlighted:
+                $ref: '#/components/schemas/highlightedValue'
+              count:
+                description: >-
+                  Number of records with this facet value. [The count may be approximated](https://support.algolia.com/hc/en-us/articles/4406975248145-Why-are-my-facet-and-hit-counts-not-accurate-).
+
+                type: integer
+        exhaustiveFacetsCount:
+          type: boolean
+          description: >
+            Whether the facet count is exhaustive (true) or approximate (false).
+            
+            For more information, see [Why are my facet and hit counts not accurate](https://support.algolia.com/hc/en-us/articles/4406975248145-Why-are-my-facet-and-hit-counts-not-accurate-).
+
+        processingTimeMS:
+          $ref: '#/components/schemas/processingTimeMS'
+    searchResult:
+      oneOf:
+        - $ref: '#/components/schemas/searchResponse'
+        - $ref: '#/components/schemas/searchForFacetValuesResponse'
+    cursor:
+      type: object
+      additionalProperties: false
+      properties:
+        cursor:
+          type: string
+          description: >
+            Cursor to get the next page of the response.
+            
+            
+            The parameter must match the value returned in the response of a previous request.
+            
+            The last page of the response does not return a `cursor` attribute.
+
+          example: jMDY3M2MwM2QwMWUxMmQwYWI0ZTN
+    browseParamsObject:
+      allOf:
+        - $ref: '#/components/schemas/searchParamsObject'
+        - $ref: '#/components/schemas/cursor'
+    browseParams:
+      oneOf:
+        - $ref: '#/components/schemas/searchParamsString'
+        - $ref: '#/components/schemas/browseParamsObject'
+    BrowsePagination:
+      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'
+    browseResponse:
+      allOf:
+        - $ref: '#/components/schemas/baseSearchResponse'
+        - $ref: '#/components/schemas/BrowsePagination'
+        - $ref: '#/components/schemas/searchHits'
+        - $ref: '#/components/schemas/cursor'
+    createdAt:
+      type: string
+      example: '2023-07-04T12:49:15Z'
+      description: Date and time when the object was created, in RFC 3339 format.
+    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.
+    updatedAt:
+      type: string
+      example: '2023-07-04T12:49:15Z'
+      description: Date and time when the object was updated, in RFC 3339 format.
+    deleteByParams:
+      type: object
+      additionalProperties: false
+      properties:
+        facetFilters:
+          $ref: '#/components/schemas/facetFilters'
+        filters:
+          $ref: '#/components/schemas/filters'
+        numericFilters:
+          $ref: '#/components/schemas/numericFilters'
+        tagFilters:
+          $ref: '#/components/schemas/tagFilters'
+        aroundLatLng:
+          $ref: '#/components/schemas/aroundLatLng'
+        aroundRadius:
+          $ref: '#/components/schemas/aroundRadius'
+        insideBoundingBox:
+          $ref: '#/components/schemas/insideBoundingBox'
+        insidePolygon:
+          $ref: '#/components/schemas/insidePolygon'
+    updatedAtResponse:
+      type: object
+      description: Response, taskID, and update timestamp.
+      additionalProperties: false
+      required:
+        - taskID
+        - updatedAt
+      properties:
+        taskID:
+          $ref: '#/components/schemas/taskID'
+        updatedAt:
+          $ref: '#/components/schemas/updatedAt'
+    action:
+      type: string
+      enum:
+        - addObject
+        - updateObject
+        - partialUpdateObject
+        - partialUpdateObjectNoCreate
+        - deleteObject
+        - delete
+        - clear
+      description: Type of indexing operation.
+    batchWriteParams:
+      title: batchWriteParams
+      description: Batch parameters.
+      type: object
+      additionalProperties: false
+      properties:
+        requests:
+          type: array
+          items:
+            title: batchRequest
+            type: object
+            additionalProperties: false
+            properties:
+              action:
+                $ref: '#/components/schemas/action'
+              body:
+                type: object
+                description: Operation arguments (varies with specified `action`).
+                example:
+                  name: Betty Jane McCamey
+                  company: Vita Foods Inc.
+                  email: betty@mccamey.com
+            required:
+              - action
+              - body
+      required:
+        - requests
+      example:
+        batch:
+          summary: Batch indexing request
+          value:
+            requests:
+              - action: addObject
+                body:
+                  name: Betty Jane McCamey
+                  company: Vita Foods Inc.
+                  email: betty@mccamey.com
+              - action: addObject
+                body:
+                  name: Gayla geimer
+                  company: Ortman McCain Co.
+                  email: gayla@geimer.com
+    objectIDs:
+      type: array
+      items:
+        type: string
+      example:
+        - record-1
+        - record-2
+      description: Unique record identifiers.
+    batchResponse:
+      type: object
+      additionalProperties: false
+      properties:
+        taskID:
+          $ref: '#/components/schemas/taskID'
+        objectIDs:
+          $ref: '#/components/schemas/objectIDs'
+      required:
+        - taskID
+        - objectIDs
+    baseIndexSettings:
+      type: object
+      additionalProperties: false
+      properties:
+        attributesForFaceting:
+          type: array
+          items:
+            type: string
+          example:
+            - author
+            - filterOnly(isbn)
+            - searchable(edition)
+            - afterDistinct(category)
+            - afterDistinct(searchable(publisher))
+          description: >
+            Attributes used for [faceting](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/).
+            
+            
+            Facets are attributes that let you categorize search results.
+            
+            They can be used for filtering search results.
+            
+            By default, no attribute is used for faceting.
+            
+            Attribute names are case-sensitive.
+            
+            
+            **Modifiers**
+            
+            
+            - `filterOnly("ATTRIBUTE")`.
+              Allows using this attribute as a filter, but doesn't evalue the facet values.
+            
+            - `searchable("ATTRIBUTE")`.
+              Allows searching for facet values.
+            
+            - `afterDistinct("ATTRIBUTE")`.
+              Evaluates the facet count _after_ deduplication with `distinct`.
+              This ensures accurate facet counts.
+              You can apply this modifier to searchable facets: `afterDistinct(searchable(ATTRIBUTE))`.
+
+          x-categories:
+            - Faceting
+        replicas:
+          type: array
+          items:
+            type: string
+          example:
+            - virtual(prod_products_price_asc)
+            - dev_products_replica
+          description: >
+            Creates [replica indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas/).
+            
+            
+            Replicas are copies of a primary index with the same records but different settings, synonyms, or rules.
+            
+            If you want to offer a different ranking or sorting of your search results, you'll use replica indices.
+            
+            All index operations on a primary index are automatically forwarded to its replicas.
+            
+            To add a replica index, you must provide the complete set of replicas to this parameter.
+            
+            If you omit a replica from this list, the replica turns into a regular, standalone index that will no longer by synced with the primary index.
+            
+            
+            **Modifier**
+            
+            
+            - `virtual("REPLICA")`.
+              Create a virtual replica,
+              Virtual replicas don't increase the number of records and are optimized for [Relevant sorting](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/relevant-sort/).
+
+          x-categories:
+            - Ranking
+        paginationLimitedTo:
+          type: integer
+          example: 100
+          description: >
+            Maximum number of search results that can be obtained through pagination.
+            
+            
+            Higher pagination limits might slow down your search.
+            
+            For pagination limits above 1,000, the sorting of results beyond the 1,000th hit can't be guaranteed.
+
+          maximum: 20000
+        unretrievableAttributes:
+          type: array
+          items:
+            type: string
+          example:
+            - total_sales
+          description: >
+            Attributes that can't be retrieved at query time.
+            
+            
+            This can be useful if you want to use an attribute for ranking or to [restrict access](https://www.algolia.com/doc/guides/security/api-keys/how-to/user-restricted-access-to-data/),
+            
+            but don't want to include it in the search results.
+            
+            Attribute names are case-sensitive.
+
+          x-categories:
+            - Attributes
+        disableTypoToleranceOnWords:
+          type: array
+          items:
+            type: string
+          example:
+            - wheel
+            - 1X2BCD
+          description: >
+            Words for which you want to turn off [typo tolerance](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/).
+            
+            This also turns off [word splitting and concatenation](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/splitting-and-concatenation/) for the specified words.
+
+          x-categories:
+            - Typos
+        attributesToTransliterate:
+          description: >
+            Attributes, for which you want to support [Japanese transliteration](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations/#japanese-transliteration-and-type-ahead).
+            
+            
+            Transliteration supports searching in any of the Japanese writing systems.
+            
+            To support transliteration, you must set the indexing language to Japanese.
+            
+            Attribute names are case-sensitive.
+
+          type: array
+          items:
+            type: string
+          example:
+            - name
+            - description
+          x-categories:
+            - Languages
+        camelCaseAttributes:
+          type: array
+          items:
+            type: string
+          example:
+            - description
+          description: >
+            Attributes for which to split [camel case](https://wikipedia.org/wiki/Camel_case) words.
+            
+            Attribute names are case-sensitive.
+
+          x-categories:
+            - Languages
+        decompoundedAttributes:
+          type: object
+          example:
+            de:
+              - name
+          description: >
+            Searchable attributes to which Algolia should apply [word segmentation](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-segmentation/) (decompounding).
+            
+            Attribute names are case-sensitive.
+            
+            
+            Compound words are formed by combining two or more individual words,
+            
+            and are particularly prevalent in Germanic languages—for example, "firefighter".
+            
+            With decompounding, the individual components are indexed separately.
+            
+            
+            You can specify different lists for different languages.
+            
+            Decompounding is supported for these languages:
+            
+            Dutch (`nl`), German (`de`), Finnish (`fi`), Danish (`da`), Swedish (`sv`), and Norwegian (`no`).
+            
+            Decompounding doesn't work for words with [non-spacing mark Unicode characters](https://www.charactercodes.net/category/non-spacing_mark).
+            
+            For example, `Gartenstühle` won't be decompounded if the `ü` consists of `u` (U+0075) and `◌̈` (U+0308).
+
+          x-categories:
+            - Languages
+        indexLanguages:
+          type: array
+          items:
+            $ref: '#/components/schemas/supportedLanguage'
+          example:
+            - ja
+          description: >
+            Languages for language-specific processing steps, such as word detection and dictionary settings.
+            
+            
+            **You should always specify an indexing language.**
+            
+            If you don't specify an indexing language, the search engine uses all [supported languages](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/),
+            
+            or the languages you specified with the `ignorePlurals` or `removeStopWords` parameters.
+            
+            This can lead to unexpected search results.
+            
+            For more information, see [Language-specific configuration](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations/).
+
+          x-categories:
+            - Languages
+        disablePrefixOnAttributes:
+          type: array
+          items:
+            type: string
+          example:
+            - sku
+          description: >
+            Searchable attributes for which you want to turn off [prefix matching](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/override-search-engine-defaults/#adjusting-prefix-search).
+            
+            Attribute names are case-sensitive.
+
+          x-categories:
+            - Query strategy
+        allowCompressionOfIntegerArray:
+          type: boolean
+          description: >
+            Whether arrays with exclusively non-negative integers should be compressed for better performance.
+            
+            If true, the compressed arrays may be reordered.
+
+          x-categories:
+            - Performance
+        numericAttributesForFiltering:
+          type: array
+          items:
+            type: string
+          description: >
+            Numeric attributes that can be used as [numerical filters](https://www.algolia.com/doc/guides/managing-results/rules/detecting-intent/how-to/applying-a-custom-filter-for-a-specific-query/#numerical-filters).
+            
+            Attribute names are case-sensitive.
+            
+            
+            By default, all numeric attributes are available as numerical filters.
+            
+            For faster indexing, reduce the number of numeric attributes.
+            
+            
+            If you want to turn off filtering for all numeric attributes, specifiy an attribute that doesn't exist in your index, such as `NO_NUMERIC_FILTERING`.
+            
+            
+            **Modifier**
+            
+            
+            - `equalOnly("ATTRIBUTE")`.
+              Support only filtering based on equality comparisons `=` and `!=`.
+
+          example:
+            - equalOnly(quantity)
+            - popularity
+          x-categories:
+            - Performance
+        separatorsToIndex:
+          type: string
+          example: +#
+          description: >
+            Controls which separators are indexed.
+            
+            
+            Separators are all non-letter characters except spaces and currency characters, such as $€£¥.
+            
+            By default, separator characters aren't indexed.
+            
+            With `separatorsToIndex`, Algolia treats separator characters as separate words.
+            
+            For example, a search for `C#` would report two matches.
+
+          x-categories:
+            - Typos
+        searchableAttributes:
+          type: array
+          items:
+            type: string
+          example:
+            - title,alternative_title
+            - author
+            - unordered(text)
+            - emails.personal
+          description: >
+            Attributes used for searching. Attribute names are case-sensitive.
+            
+            
+            By default, all attributes are searchable and the [Attribute](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/#attribute) ranking criterion is turned off.
+            
+            With a non-empty list, Algolia only returns results with matches in the selected attributes.
+            
+            In addition, the Attribute ranking criterion is turned on: matches in attributes that are higher in the list of `searchableAttributes` rank first.
+            
+            To make matches in two attributes rank equally, include them in a comma-separated string, such as `"title,alternate_title"`.
+            
+            Attributes with the same priority are always unordered.
+            
+            
+            For more information, see [Searchable attributes](https://www.algolia.com/doc/guides/sending-and-managing-data/prepare-your-data/how-to/setting-searchable-attributes/).
+            
+            
+            **Modifier**
+            
+            
+            - `unordered("ATTRIBUTE")`.
+              Ignore the position of a match within the attribute.
+            
+            Without modifier, matches at the beginning of an attribute rank higer than matches at the end.
+
+          x-categories:
+            - Attributes
+        userData:
+          $ref: '#/components/schemas/userData'
+        customNormalization:
+          description: >
+            Characters and their normalized replacements.
+            
+            This overrides Algolia's default [normalization](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/normalization/).
+
+          type: object
+          additionalProperties:
+            type: object
+            additionalProperties:
+              type: string
+          x-categories:
+            - Languages
+        attributeForDistinct:
+          description: >
+            Attribute that should be used to establish groups of results.
+            
+            Attribute names are case-sensitive.
+            
+            
+            All records with the same value for this attribute are considered a group.
+            
+            You can combine `attributeForDistinct` with the `distinct` search parameter to control
+            
+            how many items per group are included in the search results.
+            
+            
+            If you want to use the same attribute also for faceting, use the `afterDistinct` modifier of the `attributesForFaceting` setting.
+            
+            This applies faceting _after_ deduplication, which will result in accurate facet counts.
+
+          example: url
+          type: string
+    indexSettings:
+      description: Index settings.
+      allOf:
+        - $ref: '#/components/schemas/baseIndexSettings'
+        - $ref: '#/components/schemas/indexSettingsAsSearchParams'
+    WithPrimary:
+      type: object
+      additionalProperties: false
+      properties:
+        primary:
+          type: string
+          description: >
+            Replica indices only: the name of the primary index for this replica.
+
+    settingsResponse:
+      allOf:
+        - $ref: '#/components/schemas/indexSettings'
+        - $ref: '#/components/schemas/WithPrimary'
+    SynonymType:
+      type: string
+      description: Synonym type.
+      example: onewaysynonym
+      enum:
+        - synonym
+        - onewaysynonym
+        - altcorrection1
+        - altcorrection2
+        - placeholder
+    synonymHit:
+      type: object
+      description: Synonym object.
+      additionalProperties: false
+      properties:
+        objectID:
+          type: string
+          description: Unique identifier of a synonym object.
+          example: synonymID
+        type:
+          $ref: '#/components/schemas/SynonymType'
+        synonyms:
+          type: array
+          items:
+            type: string
+          description: Words or phrases considered equivalent.
+          example:
+            - vehicle
+            - auto
+        input:
+          type: string
+          description: >-
+            Word or phrase to appear in query strings (for [`onewaysynonym`s](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/in-depth/one-way-synonyms/)).
+
+          example: car
+        word:
+          type: string
+          description: >-
+            Word or phrase to appear in query strings (for [`altcorrection1` and `altcorrection2`](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/in-depth/synonyms-alternative-corrections/)).
+
+          example: car
+        corrections:
+          type: array
+          items:
+            type: string
+          description: Words to be matched in records.
+          example:
+            - vehicle
+            - auto
+        placeholder:
+          type: string
+          description: >
+            [Placeholder token](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/in-depth/synonyms-placeholders/) to be put inside records.
+
+          example: <Street>
+        replacements:
+          type: array
+          items:
+            type: string
+          description: >-
+            Query words that will match the [placeholder token](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/in-depth/synonyms-placeholders/).
+
+          example:
+            - street
+            - st
+      required:
+        - objectID
+        - type
+    id:
+      type: string
+      example: '12'
+      description: Unique identifier of a synonym object.
+    synonymHits:
+      type: array
+      description: Matching synonyms.
+      items:
+        $ref: '#/components/schemas/synonymHit'
+    searchSynonymsResponse:
+      type: object
+      additionalProperties: true
+      properties:
+        hits:
+          $ref: '#/components/schemas/synonymHits'
+        nbHits:
+          $ref: '#/components/schemas/nbHits'
+      required:
+        - hits
+        - nbHits
+    keyString:
+      type: string
+      description: API key.
+      example: 13ad45b4d0a2f6ea65ecbddf6aa260f2
+    createdAtTimestamp:
+      type: integer
+      format: int64
+      example: 1656345570000
+      description: >-
+        Timestamp when the object was created, in milliseconds since the Unix epoch.
+
+    baseGetApiKeyResponse:
+      type: object
+      additionalProperties: false
+      properties:
+        value:
+          $ref: '#/components/schemas/keyString'
+        createdAt:
+          $ref: '#/components/schemas/createdAtTimestamp'
+      required:
+        - key
+        - createdAt
+    acl:
+      description: Access control list permissions.
+      type: string
+      enum:
+        - addObject
+        - analytics
+        - browse
+        - deleteObject
+        - deleteIndex
+        - editSettings
+        - inference
+        - listIndexes
+        - logs
+        - personalization
+        - recommendation
+        - search
+        - seeUnretrievableAttributes
+        - settings
+        - usage
+    apiKey:
+      type: object
+      description: API key object.
+      additionalProperties: false
+      properties:
+        acl:
+          type: array
+          description: >
+            Permissions that determine the type of API requests this key can make.
+            
+            The required ACL is listed in each endpoint's reference.
+            
+            For more information, see [access control list](https://www.algolia.com/doc/guides/security/api-keys/#access-control-list-acl).
+
+          example:
+            - search
+            - addObject
+          items:
+            $ref: '#/components/schemas/acl'
+        description:
+          type: string
+          description: Description of an API key to help you identify this API key.
+          example: Used for indexing by the CLI
+        indexes:
+          type: array
+          description: >
+            Index names or patterns that this API key can access.
+            
+            By default, an API key can access all indices in the same application.
+            
+            
+            You can use leading and trailing wildcard characters (`*`):
+            
+            
+            - `dev_*` matches all indices starting with "dev_".
+            
+            - `*_dev` matches all indices ending with "_dev".
+            
+            - `*_products_*` matches all indices containing "_products_".
+
+          example:
+            - dev_*
+            - prod_en_products
+          items:
+            type: string
+        maxHitsPerQuery:
+          type: integer
+          description: |
+            Maximum number of results this API key can retrieve in one query.
+            By default, there's no limit.
+        maxQueriesPerIPPerHour:
+          type: integer
+          description: >
+            Maximum number of API requests allowed per IP address or [user token](https://www.algolia.com/doc/guides/sending-events/concepts/usertoken/) per hour.
+            
+            
+            If this limit is reached, the API returns an error with status code `429`.
+            
+            By default, there's no limit.
+
+        queryParameters:
+          type: string
+          description: >
+            Query parameters to add when making API requests with this API key.
+            
+            
+            To restrict this API key to specific IP addresses, add the `restrictSources` parameter.
+            
+            You can only add a single source, but you can provide a range of IP addresses.
+            
+            
+            Creating an API key fails if the request is made from an IP address that's outside the restricted range.
+
+          example: typoTolerance=strict&restrictSources=192.168.1.0/24
+        referers:
+          type: array
+          description: >
+            Allowed HTTP referrers for this API key.
+            
+            
+            By default, all referrers are allowed.
+            
+            You can use leading and trailing wildcard characters (`*`):
+            
+            
+            - `https://algolia.com/*` allows all referrers starting with "https://algolia.com/"
+            
+            - `*.algolia.com` allows all referrers ending with ".algolia.com"
+            
+            - `*algolia.com*` allows all referrers in the domain "algolia.com".
+            
+            
+            Like all HTTP headers, referrers can be spoofed. Don't rely on them to secure your data.
+            
+            For more information, see [HTTP referrer restrictions](https://www.algolia.com/doc/guides/security/security-best-practices/#http-referrers-restrictions).
+
+          example:
+            - '*algolia.com*'
+          items:
+            type: string
+        validity:
+          type: integer
+          description: |
+            Duration (in seconds) after which the API key expires.
+            By default, API keys don't expire.
+          example: 86400
+      required:
+        - acl
+    getApiKeyResponse:
+      allOf:
+        - $ref: '#/components/schemas/baseGetApiKeyResponse'
+        - $ref: '#/components/schemas/apiKey'
+    addApiKeyResponse:
+      type: object
+      additionalProperties: false
+      properties:
+        key:
+          $ref: '#/components/schemas/keyString'
+        createdAt:
+          $ref: '#/components/schemas/createdAt'
+      required:
+        - key
+        - createdAt
+    ruleID:
+      title: objectID
+      type: string
+      description: Unique identifier of a rule object.
+    anchoring:
+      type: string
+      description: |
+        Which part of the search query the pattern should match:
+
+        - `startsWith`. The pattern must match the begginning of the query.
+        - `endsWith`. The pattern must match the end of the query.
+        - `is`. The pattern must match the query exactly.
+        - `contains`. The pattern must match anywhere in the query.
+
+        Empty queries are only allowed as pattern with `anchoring: is`.
+      enum:
+        - is
+        - startsWith
+        - endsWith
+        - contains
+    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
+      additionalProperties: false
+      properties:
+        pattern:
+          type: string
+          description: >
+            Query pattern that triggers the rule.
+            
+            
+            You can use either a literal string, or a special pattern `{facet:ATTRIBUTE}`, where `ATTRIBUTE` is a facet name.
+            
+            The rule is triggered if the query matches the literal string or a value of the specified facet.
+            
+            For example, with `pattern: {facet:genre}`, the rule is triggered when users search for a genre, such as "comedy".
+
+          example: '{facet:genre}'
+        anchoring:
+          $ref: '#/components/schemas/anchoring'
+        alternatives:
+          type: boolean
+          description: Whether the pattern should match plurals, synonyms, and typos.
+        context:
+          $ref: '#/components/schemas/context'
+        filters:
+          type: string
+          description: >
+            Filters that trigger the rule.
+            
+            
+            You can add add filters using the syntax `facet:value` so that the rule is triggered, when the specific filter is selected.
+            
+            You can use `filters` on its own or combine it with the `pattern` parameter.
+
+          example: genre:comedy
+    editType:
+      description: Type of edit.
+      type: string
+      enum:
+        - remove
+        - replace
+    edit:
+      type: object
+      additionalProperties: false
+      properties:
+        type:
+          $ref: '#/components/schemas/editType'
+        delete:
+          description: Text or patterns to remove from the query string.
+          type: string
+        insert:
+          description: >-
+            Text to be added in place of the deleted text inside the query string.
+
+          type: string
+    consequenceQueryObject:
+      type: object
+      additionalProperties: false
+      properties:
+        remove:
+          description: Words to remove from the search query.
+          type: array
+          items:
+            type: string
+        edits:
+          description: Changes to make to the search query.
+          type: array
+          items:
+            $ref: '#/components/schemas/edit'
+    consequenceQuery:
+      description: >
+        Replace or edit the search query.
+        
+        
+        If `consequenceQuery` is a string, the entire search query is replaced with that string.
+        
+        If `consequenceQuery` is an object, it describes incremental edits made to the query.
+
+      oneOf:
+        - $ref: '#/components/schemas/consequenceQueryObject'
+        - type: string
+    automaticFacetFilter:
+      type: object
+      description: Filter or optional filter to be applied to the search.
+      additionalProperties: false
+      properties:
+        facet:
+          type: string
+          description: >
+            Facet name to be applied as filter.
+            
+            The name must match placeholders in the `pattern` parameter.
+            
+            For example, with `pattern: {facet:genre}`, `automaticFacetFilters` must be `genre`.
+
+        score:
+          type: integer
+          description: Filter scores to give different weights to individual filters.
+        disjunctive:
+          type: boolean
+          description: >
+            Whether the filter is disjunctive or conjunctive.
+            
+            
+            If true the filter has multiple matches, multiple occurences are combined with the logical `OR` operation.
+            
+            If false, multiple occurences are combined with the logical `AND` operation.
+
+      required:
+        - facet
+    automaticFacetFilters:
+      description: >
+        Filter to be applied to the search.
+        
+        
+        You can use this to respond to search queries that match a facet value.
+        
+        For example, if users search for "comedy", which matches a facet value of the "genre" facet,
+        
+        you can filter the results to show the top-ranked comedy movies.
+
+      oneOf:
+        - type: array
+          items:
+            $ref: '#/components/schemas/automaticFacetFilter'
+        - type: array
+          items:
+            type: string
+    params:
+      type: object
+      description: >
+        Parameters to apply to this search.
+        
+        
+        You can use all search parameters, plus special `automaticFacetFilters`, `automaticOptionalFacetFilters`, and `query`.
+
+      additionalProperties: false
+      properties:
+        query:
+          $ref: '#/components/schemas/consequenceQuery'
+        automaticFacetFilters:
+          $ref: '#/components/schemas/automaticFacetFilters'
+        automaticOptionalFacetFilters:
+          $ref: '#/components/schemas/automaticFacetFilters'
+        renderingContent:
+          $ref: '#/components/schemas/renderingContent'
+    consequenceParams:
+      allOf:
+        - $ref: '#/components/schemas/baseSearchParamsWithoutQuery'
+        - $ref: '#/components/schemas/indexSettingsAsSearchParams'
+        - $ref: '#/components/schemas/params'
+    promotePosition:
+      type: integer
+      description: >-
+        Position in the search results where you want to show the promoted records.
+
+      example: 0
+    promoteObjectIDs:
+      title: objectIDs
+      description: Records to promote.
+      type: object
+      additionalProperties: false
+      properties:
+        objectIDs:
+          type: array
+          maxItems: 100
+          description: |
+            Object IDs of the records you want to promote.
+
+            The records are placed as a group at the `position`.
+            For example, if you want to promote four records to position `0`,
+            they will be the first four search results.
+          items:
+            $ref: '#/components/schemas/objectID'
+        position:
+          $ref: '#/components/schemas/promotePosition'
+      required:
+        - position
+        - objectIDs
+      x-discriminator-fields:
+        - objectIDs
+    promoteObjectID:
+      title: objectID
+      description: Record to promote.
+      type: object
+      additionalProperties: false
+      properties:
+        objectID:
+          $ref: '#/components/schemas/objectID'
+        position:
+          $ref: '#/components/schemas/promotePosition'
+      required:
+        - position
+        - objectID
+      x-discriminator-fields:
+        - objectID
+    promote:
+      oneOf:
+        - $ref: '#/components/schemas/promoteObjectIDs'
+        - $ref: '#/components/schemas/promoteObjectID'
+    consequence:
+      type: object
+      description: >
+        Effect of the rule.
+        
+        
+        For more information, see [Consequences](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/#consequences).
+
+      additionalProperties: false
+      properties:
+        params:
+          $ref: '#/components/schemas/consequenceParams'
+        promote:
+          type: array
+          maxItems: 300
+          description: >
+            Records you want to pin to a specific position in the search results.
+            
+            
+            You can promote up to 300 records, either individually, or as groups of up to 100 records each.
+
+          items:
+            $ref: '#/components/schemas/promote'
+        filterPromotes:
+          type: boolean
+          description: >
+            Whether promoted records must match an active filter for the consequence to be applied.
+            
+            
+            This ensures that user actions (filtering the search) are given a higher precendence.
+            
+            For example, if you promote a record with the `color: red` attribute, and the user filters the search for `color: blue`,
+            
+            the "red" record won't be shown.
+
+        hide:
+          type: array
+          maxItems: 50
+          description: Records you want to hide from the search results.
+          items:
+            title: consequenceHide
+            type: object
+            description: Object ID of the record to hide.
+            additionalProperties: false
+            properties:
+              objectID:
+                $ref: '#/components/schemas/objectID'
+            required:
+              - objectID
+        userData:
+          description: >
+            A JSON object with custom data that will be appended to the `userData` array in the response.
+            
+            This object isn't interpreted by the API and is limited to 1&nbsp;kB of minified JSON.
+
+          example:
+            settingID: f2a7b51e3503acc6a39b3784ffb84300
+            pluginVersion: 1.6.0
+    timeRange:
+      type: object
+      additionalProperties: false
+      properties:
+        from:
+          type: integer
+          description: When the rule should start to be active, in Unix epoch time.
+        until:
+          type: integer
+          description: When the rule should stop to be active, in Unix epoch time.
+      required:
+        - from
+        - until
+    rule:
+      type: object
+      description: Rule object.
+      additionalProperties: false
+      properties:
+        objectID:
+          $ref: '#/components/schemas/ruleID'
+        conditions:
+          type: array
+          minItems: 0
+          maxItems: 25
+          description: >
+            Conditions that trigger a rule.
+            
+            
+            Some consequences require specific conditions or don't require any condition.
+            
+            For more information, see [Conditions](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/#conditions).
+
+          items:
+            $ref: '#/components/schemas/condition'
+        consequence:
+          $ref: '#/components/schemas/consequence'
+        description:
+          type: string
+          description: >-
+            Description of the rule's purpose to help you distinguish between different rules.
+
+          example: Display a promotional banner
+        enabled:
+          type: boolean
+          description: Whether the rule is active.
+        validity:
+          type: array
+          description: Time periods when the rule is active.
+          items:
+            $ref: '#/components/schemas/timeRange'
+      required:
+        - objectID
+    updatedRuleResponse:
+      type: object
+      additionalProperties: false
+      properties:
+        objectID:
+          $ref: '#/components/schemas/ruleID'
+        updatedAt:
+          $ref: '#/components/schemas/updatedAt'
+        taskID:
+          $ref: '#/components/schemas/taskID'
+      required:
+        - objectID
+        - updatedAt
+        - taskID
+    parameters_query:
+      type: string
+      description: Search query for rules.
+    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.
+    dictionaryType:
+      type: string
+      enum:
+        - plurals
+        - stopwords
+        - compounds
+    dictionaryAction:
+      type: string
+      enum:
+        - addEntry
+        - deleteEntry
+      description: Actions to perform.
+    dictionaryEntryState:
+      type: string
+      enum:
+        - enabled
+        - disabled
+      description: Whether a dictionary entry is active.
+    dictionaryEntryType:
+      type: string
+      enum:
+        - custom
+        - standard
+      description: >-
+        Whether a dictionary entry is provided by Algolia (standard), or has been added by you (custom).
+
+    dictionaryEntry:
+      type: object
+      description: Dictionary entry.
+      additionalProperties: true
+      required:
+        - objectID
+      properties:
+        objectID:
+          type: string
+          description: Unique identifier for the dictionary entry.
+          example: 828afd405e1f4fe950b6b98c2c43c032
+        language:
+          $ref: '#/components/schemas/supportedLanguage'
+        word:
+          type: string
+          description: >-
+            Matching dictionary word for `stopwords` and `compounds` dictionaries.
+
+          example: the
+        words:
+          type: array
+          description: Matching words in the `plurals` dictionary including declensions.
+          example:
+            - cheval
+            - cheveaux
+          items:
+            type: string
+        decomposition:
+          type: array
+          description: >-
+            Invividual components of a compound word in the `compounds` dictionary.
+
+          example:
+            - kopf
+            - schmerz
+            - tablette
+          items:
+            type: string
+        state:
+          $ref: '#/components/schemas/dictionaryEntryState'
+        type:
+          $ref: '#/components/schemas/dictionaryEntryType'
+    searchDictionaryEntriesResponse:
+      type: object
+      additionalProperties: false
+      properties:
+        hits:
+          type: array
+          description: Dictionary entries matching the search criteria.
+          items:
+            $ref: '#/components/schemas/dictionaryEntry'
+        page:
+          $ref: '#/components/schemas/parameters_page'
+        nbHits:
+          $ref: '#/components/schemas/nbHits'
+        nbPages:
+          $ref: '#/components/schemas/nbPages'
+      required:
+        - hits
+        - page
+        - nbHits
+        - nbPages
+    standardEntry:
+      oneOf:
+        - type: object
+          description: Key-value pair of a language ISO code and a boolean value.
+          example:
+            fr: false
+          additionalProperties:
+            x-additionalPropertiesName: language
+            type: boolean
+        - type: 'null'
+    standardEntries:
+      description: >
+        Key-value pairs of [supported language ISO codes](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/) and boolean values.
+
+      additionalProperties: false
+      properties:
+        plurals:
+          $ref: '#/components/schemas/standardEntry'
+        stopwords:
+          $ref: '#/components/schemas/standardEntry'
+        compounds:
+          $ref: '#/components/schemas/standardEntry'
+    dictionaryLanguage:
+      oneOf:
+        - type: object
+          additionalProperties: false
+          description: >-
+            Dictionary type. If `null`, this dictionary type isn't supported for the language.
+
+          properties:
+            nbCustomEntries:
+              description: Number of custom dictionary entries.
+              type: integer
+        - type: 'null'
+    languages:
+      type: object
+      description: Dictionary language.
+      additionalProperties: false
+      required:
+        - plurals
+        - stopwords
+        - compounds
+      properties:
+        plurals:
+          $ref: '#/components/schemas/dictionaryLanguage'
+        stopwords:
+          $ref: '#/components/schemas/dictionaryLanguage'
+        compounds:
+          $ref: '#/components/schemas/dictionaryLanguage'
+    userID:
+      type: string
+      pattern: ^[a-zA-Z0-9 \-*.]+$
+      description: Unique identifier of the user who makes the search request.
+      example: user1
+    userId:
+      title: userID
+      type: object
+      description: Unique user ID.
+      properties:
+        userID:
+          $ref: '#/components/schemas/userID'
+        clusterName:
+          type: string
+          description: Cluster to which the user is assigned.
+          example: c1-test
+        nbRecords:
+          type: integer
+          description: Number of records belonging to the user.
+          example: 42
+        dataSize:
+          type: integer
+          description: Data size used by the user.
+          example: 0
+      required:
+        - userID
+        - clusterName
+        - nbRecords
+        - dataSize
+    clusterName:
+      type: string
+      description: Cluster name.
+      example: c11-test
+    nbRecords:
+      type: integer
+      description: Number of records in the cluster.
+      example: 3
+    dataSize:
+      type: integer
+      description: Data size taken by all the users assigned to the cluster.
+      example: 481
+    source:
+      description: Source.
+      required:
+        - source
+      properties:
+        source:
+          description: IP address range of the source.
+          type: string
+          example: 10.0.0.1/32
+        description:
+          description: Source description.
+          type: string
+          example: Server subnet
+    sources:
+      description: Sources.
+      type: array
+      items:
+        $ref: '#/components/schemas/source'
+    logType:
+      type: string
+      enum:
+        - all
+        - query
+        - build
+        - error
+    taskStatus:
+      type: string
+      enum:
+        - published
+        - notPublished
+      description: >-
+        Task status, `published` if the task is completed, `notPublished` otherwise.
+
+    GetTaskResponse:
+      title: getTaskResponse
+      type: object
+      additionalProperties: false
+      properties:
+        status:
+          $ref: '#/components/schemas/taskStatus'
+      required:
+        - status
+    operationType:
+      type: string
+      enum:
+        - move
+        - copy
+      example: copy
+      description: Operation to perform on the index.
+    scopeType:
+      type: string
+      enum:
+        - settings
+        - synonyms
+        - rules
+    fetchedIndex:
+      type: object
+      additionalProperties: false
+      properties:
+        name:
+          type: string
+          description: Index name.
+          example: movies
+        createdAt:
+          type: string
+          description: >-
+            Index creation date. An empty string means that the index has no records.
+
+          example: '2022-09-19T16:36:44.471Z'
+        updatedAt:
+          $ref: '#/components/schemas/updatedAt'
+        entries:
+          type: integer
+          description: Number of records contained in the index.
+          example: 100
+        dataSize:
+          type: integer
+          description: Number of bytes of the index in minified format.
+          example: 48450
+        fileSize:
+          type: integer
+          description: Number of bytes of the index binary file.
+          example: 112927
+        lastBuildTimeS:
+          type: integer
+          description: Last build time.
+          example: 3
+        numberOfPendingTasks:
+          type: integer
+          description: >-
+            Number of pending indexing operations. This value is deprecated and should not be used.
+
+        pendingTask:
+          type: boolean
+          description: >-
+            A boolean which says whether the index has pending tasks. This value is deprecated and should not be used.
+
+        primary:
+          type: string
+          description: >-
+            Only present if the index is a replica. Contains the name of the related primary index.
+
+          example: T02
+        replicas:
+          type: array
+          items:
+            type: string
+          description: >-
+            Only present if the index is a primary index with replicas. Contains the names of all linked replicas.
+
+          example:
+            - T02_push
+            - T2replica
+        virtual:
+          type: boolean
+          description: >-
+            Only present if the index is a [virtual replica](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/sort-an-index-alphabetically/#virtual-replicas).
+
+          x-categories:
+            - Ranking
+      required:
+        - name
+        - createdAt
+        - updatedAt
+        - entries
+        - dataSize
+        - fileSize
+        - lastBuildTimeS
+        - pendingTask
+        - numberOfPendingTasks
+    listIndicesResponse:
+      type: object
+      additionalProperties: false
+      properties:
+        items:
+          type: array
+          description: All indices in your Algolia application.
+          items:
+            $ref: '#/components/schemas/fetchedIndex'
+        nbPages:
+          type: integer
+          description: Number of pages.
+          example: 100
+      required:
+        - items
+    apiKeyOperation:
+      type: string
+      enum:
+        - add
+        - delete
+        - update
+    securedApiKeyRestrictions:
+      type: object
+      additionalProperties: false
+      properties:
+        searchParams:
+          $ref: '#/components/schemas/searchParamsObject'
+        filters:
+          type: string
+          description: >
+            Filters that apply to every search made with the secured API key.
+            
+            Extra filters added at search time will be combined with `AND`.
+            
+            For example, if you set `group:admin` as fixed filter on your generated API key,
+            
+            and add `groups:visitors` to the search query, the complete set of filters will be `group:admin AND groups:visitors`.
+
+        validUntil:
+          type: integer
+          format: int64
+          description: >-
+            Timestamp when the secured API key expires, measured in seconds since the Unix epoch.
+
+        restrictIndices:
+          type: array
+          items:
+            type: string
+          description: >
+            Index names or patterns that this API key can access.
+            
+            By default, an API key can access all indices in the same application.
+            
+            
+            You can use leading and trailing wildcard characters (`*`):
+            
+            
+            - `dev_*` matches all indices starting with "dev_".
+            
+            - `*_dev` matches all indices ending with "_dev".
+            
+            - `*_products_*` matches all indices containing "_products_".
+
+        restrictSources:
+          type: string
+          description: >
+            IP network that are allowed to use this key.
+            
+            
+            You can only add a single source, but you can provide a range of IP addresses.
+            
+            Use this to protect against API key leaking and reuse.
+
+          example: 192.168.1.0/24
+        userToken:
+          type: string
+          description: >
+            Pseudonymous user identifier to restrict usage of this API key to specific users.
+            
+            
+            By default, rate limits are set based on IP addresses. This can be an issue if many users search from the same IP address.
+            
+            To avoid this, add a user token to each generated API key.
+
+    replaceAllObjectsResponse:
+      type: object
+      additionalProperties: false
+      properties:
+        copyOperationResponse:
+          description: >-
+            The response of the `operationIndex` request for the `copy` operation.
+
+          $ref: '#/components/schemas/updatedAtResponse'
+        batchResponses:
+          type: array
+          description: The response of the `batch` request(s).
+          items:
+            $ref: '#/components/schemas/batchResponse'
+        moveOperationResponse:
+          description: >-
+            The response of the `operationIndex` request for the `move` operation.
+
+          $ref: '#/components/schemas/updatedAtResponse'
+      required:
+        - copyOperationResponse
+        - batchResponses
+        - moveOperationResponse
+    builtInOperationType:
+      type: string
+      enum:
+        - Increment
+        - Decrement
+        - Add
+        - Remove
+        - AddUnique
+        - IncrementFrom
+        - IncrementSet
+      description: How to change the attribute.
+    builtInOperationValue:
+      oneOf:
+        - type: string
+          description: >-
+            A string to append or remove for the `Add`, `Remove`, and `AddUnique` operations.
+
+        - type: integer
+          description: A number to add, remove, or append, depending on the operation.
+    builtInOperation:
+      type: object
+      description: Update to perform on the attribute.
+      additionalProperties: false
+      properties:
+        _operation:
+          $ref: '#/components/schemas/builtInOperationType'
+        value:
+          $ref: '#/components/schemas/builtInOperationValue'
+      required:
+        - _operation
+        - value
+  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
+    ObjectID:
+      name: objectID
+      in: path
+      description: Unique record identifier.
+      required: true
+      schema:
+        $ref: '#/components/schemas/objectID'
+    ForwardToReplicas:
+      in: query
+      name: forwardToReplicas
+      required: false
+      description: Whether changes are applied to replica indices.
+      schema:
+        type: boolean
+    parameters_ObjectID:
+      name: objectID
+      in: path
+      description: Unique identifier of a synonym object.
+      required: true
+      schema:
+        type: string
+        example: synonymID
+    ReplaceExistingSynonyms:
+      in: query
+      name: replaceExistingSynonyms
+      schema:
+        type: boolean
+      description: >-
+        Whether to replace all synonyms in the index with the ones sent with this request.
+
+    KeyString:
+      in: path
+      name: key
+      required: true
+      schema:
+        type: string
+        example: YourAPIKey
+      description: API key.
+    ObjectIDRule:
+      in: path
+      name: objectID
+      description: Unique identifier of a rule object.
+      required: true
+      schema:
+        $ref: '#/components/schemas/ruleID'
+    ClearExistingRules:
+      in: query
+      name: clearExistingRules
+      required: false
+      schema:
+        type: boolean
+      description: Whether existing rules should be deleted before adding this batch.
+    DictionaryName:
+      in: path
+      name: dictionaryName
+      description: Dictionary type in which to search.
+      required: true
+      schema:
+        $ref: '#/components/schemas/dictionaryType'
+    Page:
+      in: query
+      name: page
+      description: |
+        Requested page of the API response.
+        If `null`, the API response is not paginated.
+      required: false
+      schema:
+        oneOf:
+          - type: integer
+            minimum: 0
+          - type: 'null'
+        default: null
+    HitsPerPage:
+      in: query
+      name: hitsPerPage
+      description: Number of hits per page.
+      required: false
+      schema:
+        type: integer
+        default: 100
+    UserIDInHeader:
+      name: X-Algolia-User-ID
+      description: Unique identifier of the user who makes the search request.
+      in: header
+      required: true
+      schema:
+        $ref: '#/components/schemas/userID'
+    UserIDInPath:
+      name: userID
+      description: Unique identifier of the user who makes the search request.
+      in: path
+      required: true
+      schema:
+        $ref: '#/components/schemas/userID'
+  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'
+    UpdatedAtWithObjectId:
+      description: OK
+      content:
+        application/json:
+          schema:
+            title: updatedAtWithObjectIdResponse
+            description: >-
+              Response, taskID, unique object identifier, and an update timestamp.
+
+            additionalProperties: false
+            type: object
+            properties:
+              taskID:
+                $ref: '#/components/schemas/taskID'
+              updatedAt:
+                $ref: '#/components/schemas/updatedAt'
+              objectID:
+                $ref: '#/components/schemas/objectID'
+    UpdatedAt:
+      description: OK
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/updatedAtResponse'
+    CreatedAt:
+      description: OK
+      content:
+        application/json:
+          schema:
+            title: createdAtResponse
+            description: Response and creation timestamp.
+            additionalProperties: false
+            type: object
+            required:
+              - createdAt
+            properties:
+              createdAt:
+                $ref: '#/components/schemas/createdAt'
+x-tagGroups:
+  - name: Search and indexing
+    tags:
+      - Indices
+      - Records
+      - Search
+  - name: Relevance
+    tags:
+      - Rules
+      - Synonyms
+      - Dictionaries
+  - name: Others
+    tags:
+      - Api Keys
+      - Clusters
+      - Vaults
+      - Advanced
+  - name: Models
+    tags:
+      - _model_index_settings