algoliasearch 5.0.0-alpha.106 → 5.0.0-alpha.108

package/dist/lite/model/baseSearchParamsWithoutQuery.d.ts

@@ -6,11 +6,11 @@ import type { OptionalFilters } from './optionalFilters';
 import type { TagFilters } from './tagFilters';
 export type BaseSearchParamsWithoutQuery = {
     /**
-     * Overrides the query parameter and performs a more generic search.
+     * 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.
      */
     similarQuery?: string;
     /**
-     * [Filter](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/) the query with numeric, facet, or tag filters.
+     * Filter the search so that only records with matching values are included in the results.  These filters are supported:  - **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/).
      */
     filters?: string;
     facetFilters?: FacetFilters;
@@ -18,89 +18,85 @@ export type BaseSearchParamsWithoutQuery = {
     numericFilters?: NumericFilters;
     tagFilters?: TagFilters;
     /**
-     * Determines how to calculate [filter scores](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/in-depth/filter-scoring/#accumulating-scores-with-sumorfiltersscores). If `false`, maximum score is kept. If `true`, score is summed.
+     * 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).
      */
     sumOrFiltersScores?: boolean;
     /**
-     * Restricts a query to only look at a subset of your [searchable attributes](https://www.algolia.com/doc/guides/managing-results/must-do/searchable-attributes/).
+     * Restricts a search to a subset of your searchable attributes.
      */
     restrictSearchableAttributes?: string[];
     /**
-     * Returns [facets](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#contextual-facet-values-and-counts), their facet values, and the number of matching facet values.
+     * 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).
      */
     facets?: string[];
     /**
-     * Forces faceting to be applied after [de-duplication](https://www.algolia.com/doc/guides/managing-results/refine-results/grouping/) (with the distinct feature). Alternatively, the `afterDistinct` [modifier](https://www.algolia.com/doc/api-reference/api-parameters/attributesForFaceting/#modifiers) of `attributesForFaceting` allows for more granular control.
+     * 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`.
      */
     facetingAfterDistinct?: boolean;
     /**
-     * Page to retrieve (the first page is `0`, not `1`).
+     * Page of search results to retrieve.
      */
     page?: number;
     /**
-     * Specifies the offset of the first hit to return. > **Note**: Using `page` and `hitsPerPage` is the recommended method for [paging results](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/). However, you can use `offset` and `length` to implement [an alternative approach to paging](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/#retrieving-a-subset-of-records-with-offset-and-length).
+     * Position of the first hit to retrieve.
      */
     offset?: number;
     /**
-     * Sets the number of hits to retrieve (for use with `offset`). > **Note**: Using `page` and `hitsPerPage` is the recommended method for [paging results](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/). However, you can use `offset` and `length` to implement [an alternative approach to paging](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/#retrieving-a-subset-of-records-with-offset-and-length).
+     * Number of hits to retrieve (used in combination with `offset`).
      */
     length?: number;
     /**
-     * Search for entries [around a central location](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filter-around-a-central-point), enabling a geographical search within a circular area.
+     * 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`.
      */
     aroundLatLng?: string;
     /**
-     * Search for entries around a location. The location is automatically computed from the requester\'s IP address.
+     * Whether to obtain the coordinates from the request\'s IP address.
      */
     aroundLatLngViaIP?: boolean;
     aroundRadius?: AroundRadius;
     aroundPrecision?: AroundPrecision;
     /**
-     * Minimum radius (in meters) used for a geographical search when `aroundRadius` isn\'t set.
+     * Minimum radius (in meters) for a search around a location when `aroundRadius` isn\'t set.
      */
     minimumAroundRadius?: number;
     /**
-     * Search inside a [rectangular area](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas) (in geographical coordinates).
+     * 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).
      */
     insideBoundingBox?: number[][];
     /**
-     * Search inside a [polygon](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas) (in geographical coordinates).
+     * 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`.
      */
     insidePolygon?: number[][];
     /**
-     * Changes the default values of parameters that work best for a natural language query, such as `ignorePlurals`, `removeStopWords`, `removeWordsIfNoResults`, `analyticsTags`, and `ruleContexts`. These parameters work well together when the query consists of fuller natural language strings instead of keywords, for example when processing voice search queries.
+     * 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`.
      */
     naturalLanguages?: string[];
     /**
-     * Assigns [rule contexts](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/how-to/customize-search-results-by-platform/#whats-a-context) to search queries.
+     * 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.
      */
     ruleContexts?: string[];
     /**
-     * Defines how much [Personalization affects results](https://www.algolia.com/doc/guides/personalization/personalizing-results/in-depth/configuring-personalization/#understanding-personalization-impact).
+     * 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).
      */
     personalizationImpact?: number;
     /**
-     * Associates a [user token](https://www.algolia.com/doc/guides/sending-events/concepts/usertoken/) with the current search.
+     * 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/).
      */
     userToken?: string;
     /**
-     * Incidates whether the search response includes [detailed ranking information](https://www.algolia.com/doc/guides/building-search-ui/going-further/backend-search/in-depth/understanding-the-api-response/#ranking-information).
+     * Whether the search response should include detailed ranking information.
      */
     getRankingInfo?: boolean;
     /**
-     * Enriches the API\'s response with information about how the query was processed.
-     */
-    explain?: string[];
-    /**
-     * Whether to take into account an index\'s synonyms for a particular search.
+     * Whether to take into account an index\'s synonyms for this search.
      */
     synonyms?: boolean;
     /**
-     * Indicates whether a query ID parameter is included in the search response. This is required for [tracking click and conversion events](https://www.algolia.com/doc/guides/sending-events/concepts/event-types/#events-related-to-algolia-requests).
+     * 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/).
      */
     clickAnalytics?: boolean;
     /**
-     * Indicates whether this query will be included in [analytics](https://www.algolia.com/doc/guides/search-analytics/guides/exclude-queries/).
+     * Whether this search will be included in Analytics.
      */
     analytics?: boolean;
     /**
@@ -108,11 +104,11 @@ export type BaseSearchParamsWithoutQuery = {
      */
     analyticsTags?: string[];
     /**
-     * Whether to include or exclude a query from the processing-time percentile computation.
+     * Whether to include this search when calculating processing-time percentiles.
      */
     percentileComputation?: boolean;
     /**
-     * Incidates whether this search will be considered in A/B testing.
+     * Whether to enable A/B testing for this search.
      */
     enableABTest?: boolean;
 };

package/dist/lite/model/baseSearchParamsWithoutQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"baseSearchParamsWithoutQuery.d.ts","sourceRoot":"","sources":["../../../lite/model/baseSearchParamsWithoutQuery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,4BAA4B,GAAG;IACzC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC,UAAU,CAAC,EAAE,UAAU,CAAC;IAExB;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,4BAA4B,CAAC,EAAE,MAAM,EAAE,CAAC;IAExC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB;;OAEG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC;;OAEG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAE/B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAE3B;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE5B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;OAEG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC"}
+{"version":3,"file":"baseSearchParamsWithoutQuery.d.ts","sourceRoot":"","sources":["../../../lite/model/baseSearchParamsWithoutQuery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,MAAM,MAAM,4BAA4B,GAAG;IACzC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC,UAAU,CAAC,EAAE,UAAU,CAAC;IAExB;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;OAEG;IACH,4BAA4B,CAAC,EAAE,MAAM,EAAE,CAAC;IAExC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAElB;;OAEG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC;;OAEG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAE/B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAE3B;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE5B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;OAEG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;OAEG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC"}

package/dist/lite/model/baseSearchResponse.d.ts

@@ -16,7 +16,7 @@ export type BaseSearchResponse = Record<string, any> & {
      */
     aroundLatLng?: string;
     /**
-     * Automatically-computed radius.
+     * Distance from a central coordinate provided by `aroundLatLng`.
      */
     automaticRadius?: string;
     exhaustive?: Exhaustive;
@@ -33,7 +33,7 @@ export type BaseSearchResponse = Record<string, any> & {
      */
     exhaustiveTypo?: boolean;
     /**
-     * Mapping of each facet name to the corresponding facet counts.
+     * Facet counts.
      */
     facets?: Record<string, Record<string, number>>;
     /**
@@ -57,11 +57,11 @@ export type BaseSearchResponse = Record<string, any> & {
      */
     message?: string;
     /**
-     * Number of hits the search query matched.
+     * Number of results (hits).
      */
     nbHits: number;
     /**
-     * Number of pages of results for the current query.
+     * Number of pages of results.
      */
     nbPages: number;
     /**
@@ -69,7 +69,7 @@ export type BaseSearchResponse = Record<string, any> & {
      */
     nbSortedHits?: number;
     /**
-     * Page to retrieve (the first page is `0`, not `1`).
+     * Page of search results to retrieve.
      */
     page: number;
     /**
@@ -99,7 +99,7 @@ export type BaseSearchResponse = Record<string, any> & {
      */
     serverUsed?: string;
     /**
-     * Lets you store custom data in your indices.
+     * An object with custom data.  You can store up to 32&nbsp;kB as custom data.
      */
     userData?: any | null;
     /**

package/dist/lite/model/builtInOperation.d.ts

@@ -1,11 +1,11 @@
 import type { BuiltInOperationType } from './builtInOperationType';
 /**
- * To update an attribute without pushing the entire record, you can use these built-in operations.
+ * Update to perform on the attribute.
  */
 export type BuiltInOperation = {
     _operation: BuiltInOperationType;
     /**
-     * Value that corresponds to the operation, for example an `Increment` or `Decrement` step, `Add` or `Remove` value.
+     * Value that corresponds to the operation, for example an `Increment` or `Decrement` step, or an `Add` or `Remove` value.
      */
     value: string;
 };

package/dist/lite/model/builtInOperationType.d.ts

@@ -1,5 +1,5 @@
 /**
- * Operation to apply to the attribute.
+ * How to change the attribute.
  */
 export type BuiltInOperationType = 'Add' | 'AddUnique' | 'Decrement' | 'Increment' | 'IncrementFrom' | 'IncrementSet' | 'Remove';
 //# sourceMappingURL=builtInOperationType.d.ts.map

package/dist/lite/model/condition.d.ts

@@ -1,17 +1,21 @@
 import type { Anchoring } from './anchoring';
 export type Condition = {
     /**
-     * Query pattern syntax.
+     * 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\".
      */
     pattern?: string;
     anchoring?: Anchoring;
     /**
-     * Whether the pattern matches on plurals, synonyms, and typos.
+     * Whether the pattern should match plurals, synonyms, and typos.
      */
     alternatives?: boolean;
     /**
-     * Rule context format: [A-Za-z0-9_-]+).
+     * 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.
      */
     context?: string;
+    /**
+     * 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.
+     */
+    filters?: string;
 };
 //# sourceMappingURL=condition.d.ts.map

package/dist/lite/model/condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condition.d.ts","sourceRoot":"","sources":["../../../lite/model/condition.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}
+{"version":3,"file":"condition.d.ts","sourceRoot":"","sources":["../../../lite/model/condition.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;OAEG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC"}

package/dist/lite/model/consequence.d.ts

@@ -2,24 +2,24 @@ import type { ConsequenceHide } from './consequenceHide';
 import type { ConsequenceParams } from './consequenceParams';
 import type { Promote } from './promote';
 /**
- * [Consequences](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/#consequences) of a rule.
+ * Effect of the rule.  For more information, see [Consequences](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/#consequences).
  */
 export type Consequence = {
     params?: ConsequenceParams;
     /**
-     * Records to promote.
+     * 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.
      */
     promote?: Promote[];
     /**
-     * Only use in combination with the `promote` consequence. When `true`, promoted results will be restricted to match the filters of the current search. When `false`, the promoted results will show up regardless of the filters.
+     * 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.
      */
     filterPromotes?: boolean;
     /**
-     * Records to hide. By default, you can hide up to 50 records per rule.
+     * Records you want to hide from the search results.
      */
     hide?: ConsequenceHide[];
     /**
-     * Custom JSON object that will be appended to the userData array in the response. This object isn\'t interpreted by the API. It\'s limited to 1kB of minified JSON.
+     * 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 kB of minified JSON.
      */
     userData?: any | null;
 };

package/dist/lite/model/consequenceHide.d.ts

@@ -1,9 +1,9 @@
 /**
- * Unique identifier of the record to hide.
+ * Object ID of the record to hide.
  */
 export type ConsequenceHide = {
     /**
-     * Unique object identifier.
+     * Unique record identifier.
      */
     objectID: string;
 };

package/dist/lite/model/consequenceQuery.d.ts

@@ -1,6 +1,6 @@
 import type { ConsequenceQueryObject } from './consequenceQueryObject';
 /**
- * When providing a string, it replaces the entire query string. When providing an object, it describes incremental edits to be made to the query string (but you can\'t do both).
+ * 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.
  */
 export type ConsequenceQuery = ConsequenceQueryObject | string;
 //# sourceMappingURL=consequenceQuery.d.ts.map

package/dist/lite/model/consequenceQueryObject.d.ts

@@ -1,11 +1,11 @@
 import type { Edit } from './edit';
 export type ConsequenceQueryObject = {
     /**
-     * Words to remove.
+     * Words to remove from the search query.
      */
     remove?: string[];
     /**
-     * Edits to apply.
+     * Changes to make to the search query.
      */
     edits?: Edit[];
 };

package/dist/lite/model/cursor.d.ts

@@ -1,6 +1,6 @@
 export type Cursor = {
     /**
-     * Cursor indicating the location to resume browsing from. Must match the value returned by the previous call. Pass this value to the subsequent browse call to get the next page of results. When the end of the index has been reached, `cursor` is absent from the response.
+     * 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.
      */
     cursor?: string;
 };

package/dist/lite/model/deleteByParams.d.ts

@@ -5,22 +5,22 @@ import type { TagFilters } from './tagFilters';
 export type DeleteByParams = {
     facetFilters?: FacetFilters;
     /**
-     * [Filter](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/) the query with numeric, facet, or tag filters.
+     * Filter the search so that only records with matching values are included in the results.  These filters are supported:  - **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/).
      */
     filters?: string;
     numericFilters?: NumericFilters;
     tagFilters?: TagFilters;
     /**
-     * Search for entries [around a central location](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filter-around-a-central-point), enabling a geographical search within a circular area.
+     * 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`.
      */
     aroundLatLng?: string;
     aroundRadius?: AroundRadius;
     /**
-     * Search inside a [rectangular area](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas) (in geographical coordinates).
+     * 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).
      */
     insideBoundingBox?: number[][];
     /**
-     * Search inside a [polygon](https://www.algolia.com/doc/guides/managing-results/refine-results/geolocation/#filtering-inside-rectangular-or-polygonal-areas) (in geographical coordinates).
+     * 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`.
      */
     insidePolygon?: number[][];
 };

package/dist/lite/model/dictionaryEntry.d.ts

@@ -1,26 +1,24 @@
 import type { DictionaryEntryState } from './dictionaryEntryState';
+import type { SupportedLanguage } from './supportedLanguage';
 /**
  * Dictionary entry.
  */
 export type DictionaryEntry = Record<string, any> & {
     /**
-     * Unique identifier for a dictionary object.
+     * Unique identifier for the dictionary entry.
      */
     objectID: string;
+    language: SupportedLanguage;
     /**
-     * [Supported language ISO code](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/).
-     */
-    language: string;
-    /**
-     * Dictionary entry word. Usage depends on the type of dictionary entry. **`stopwordEntry`** The stop word you want to add or update. If the entry already exists in Algolia\'s standard dictionary, you can override its behavior by adding it to the custom dictionary and setting its `state` to `disabled`. **`compoundEntry`** When `decomposition` is empty: adds `word` as a compound atom. For example, atom “kino” decomposes the query “kopfkino” into \"kopf\" and \"kino\". When `decomposition` isn\'t empty: creates a decomposition exception. For example, when decomposition is set to the [\"hund\", \"hutte\"] exception, \"hundehutte\" decomposes into “hund” and “hutte”, discarding the linking \"e\".
+     * Matching dictionary word for `stopwords` and `compounds` dictionaries.
      */
     word?: string;
     /**
-     * Compound dictionary [word declensions](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-plurals-and-other-declensions/). If the entry already exists in Algolia\'s standard dictionary, you can override its behavior by adding it to the custom dictionary and setting its `state` to `disabled`.
+     * Matching words in the `plurals` dictionary including declensions.
      */
     words?: string[];
     /**
-     * For compound entries, governs the behavior of the `word` parameter.
+     * Invividual components of a compound word in the `compounds` dictionary.
      */
     decomposition?: string[];
     state?: DictionaryEntryState;

package/dist/lite/model/dictionaryEntry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dictionaryEntry.d.ts","sourceRoot":"","sources":["../../../lite/model/dictionaryEntry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAEnE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAClD;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAEjB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB,KAAK,CAAC,EAAE,oBAAoB,CAAC;CAC9B,CAAC"}
+{"version":3,"file":"dictionaryEntry.d.ts","sourceRoot":"","sources":["../../../lite/model/dictionaryEntry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG;IAClD;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB,QAAQ,EAAE,iBAAiB,CAAC;IAE5B;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IAEjB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB,KAAK,CAAC,EAAE,oBAAoB,CAAC;CAC9B,CAAC"}

package/dist/lite/model/dictionaryEntryState.d.ts

@@ -1,5 +1,5 @@
 /**
- * Indicates whether a dictionary entry is active (`enabled`) or inactive (`disabled`).
+ * Whether a dictionary entry is active.
  */
 export type DictionaryEntryState = 'disabled' | 'enabled';
 //# sourceMappingURL=dictionaryEntryState.d.ts.map

package/dist/lite/model/dictionaryLanguage.d.ts

@@ -1,9 +1,9 @@
 /**
- * Custom entries for a dictionary.
+ * Dictionary type. If `null`, this dictionary type isn\'t supported for the language.
  */
 export type DictionaryLanguage = {
     /**
-     * If `0`, the dictionary hasn\'t been customized and only contains standard entries provided by Algolia. If `null`, that feature isn\'t available or isn\'t supported for that language.
+     * Number of custom dictionary entries.
      */
     nbCustomEntries?: number;
 };

package/dist/lite/model/distinct.d.ts

@@ -1,5 +1,5 @@
 /**
- * Enables [deduplication or grouping of results (Algolia\'s _distinct_ feature](https://www.algolia.com/doc/guides/managing-results/refine-results/grouping/#introducing-algolias-distinct-feature)).
+ * 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.
  */
 export type Distinct = boolean | number;
 //# sourceMappingURL=distinct.d.ts.map

package/dist/lite/model/edit.d.ts

@@ -6,7 +6,7 @@ export type Edit = {
      */
     delete?: string;
     /**
-     * Text that should be inserted in place of the removed text inside the query string.
+     * Text to be added in place of the deleted text inside the query string.
      */
     insert?: string;
 };

package/dist/lite/model/exactOnSingleWordQuery.d.ts

@@ -1,5 +1,5 @@
 /**
- * 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 query contains only one word.
+ * 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.  <dl> <dt><code>attribute</code></dt> <dd> 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\". </dd> <dt><code>none</code></dt> <dd> The Exact ranking criterion is ignored on single-word searches. </dd> <dt><code>word</code></dt> <dd> 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. </dd> </dl>  If `exactOnSingleWordQuery` is `word`, only exact matches will be highlighted, partial and prefix matches won\'t.
  */
 export type ExactOnSingleWordQuery = 'attribute' | 'none' | 'word';
 //# sourceMappingURL=exactOnSingleWordQuery.d.ts.map

package/dist/lite/model/facetFilters.d.ts

@@ -1,6 +1,6 @@
 import type { MixedSearchFilters } from './mixedSearchFilters';
 /**
- * [Filter hits by facet value](https://www.algolia.com/doc/api-reference/api-parameters/facetFilters/).
+ * 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`.
  */
 export type FacetFilters = MixedSearchFilters[] | string;
 //# sourceMappingURL=facetFilters.d.ts.map

package/dist/lite/model/facetHits.d.ts

@@ -4,11 +4,11 @@ export type FacetHits = {
      */
     value: string;
     /**
-     * Markup text with `facetQuery` matches highlighted.
+     * Highlighted attribute value, including HTML tags.
      */
     highlighted: string;
     /**
-     * Number of records containing this facet value. This takes into account the extra search parameters specified in the query. Like for a regular search query, the [counts may not be exhaustive](https://support.algolia.com/hc/en-us/articles/4406975248145-Why-are-my-facet-and-hit-counts-not-accurate-).
+     * 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-).
      */
     count: number;
 };

package/dist/lite/model/facetOrdering.d.ts

@@ -1,12 +1,12 @@
 import type { Facets } from './facets';
 import type { Value } from './value';
 /**
- * Defines the ordering of facets (widgets).
+ * Order of facet names and facet values in your UI.
  */
 export type FacetOrdering = {
     facets?: Facets;
     /**
-     * Ordering of facet values within an individual facet.
+     * Order of facet values. One object for each facet.
      */
     values?: Record<string, Value>;
 };

package/dist/lite/model/facets.d.ts

@@ -1,9 +1,9 @@
 /**
- * Ordering of facets (widgets).
+ * Order of facet names.
  */
 export type Facets = {
     /**
-     * Pinned order of facet lists.
+     * Explicit order of facets or facet values.  This setting lets you always show specific facets or facet values at the top of the list.
      */
     order?: string[];
 };

package/dist/lite/model/highlightResultOption.d.ts

@@ -1,15 +1,15 @@
 import type { MatchLevel } from './matchLevel';
 /**
- * Show highlighted section and words matched on a query.
+ * Surround words that match the query with HTML tags for highlighting.
  */
 export type HighlightResultOption = {
     /**
-     * Markup text with `facetQuery` matches highlighted.
+     * Highlighted attribute value, including HTML tags.
      */
     value: string;
     matchLevel: MatchLevel;
     /**
-     * List of words from the query that matched the object.
+     * List of matched words from the search query.
      */
     matchedWords: string[];
     /**

package/dist/lite/model/hit.d.ts

@@ -2,19 +2,19 @@ import type { HighlightResult } from './highlightResult';
 import type { RankingInfo } from './rankingInfo';
 import type { SnippetResult } from './snippetResult';
 /**
- * A single hit.
+ * Search result.  A hit is a record from your index, augmented with special attributes for highlighting, snippeting, and ranking.
  */
 export type Hit<T = Record<string, any>> = T & {
     /**
-     * Unique object identifier.
+     * Unique record identifier.
      */
     objectID: string;
     /**
-     * Show highlighted section and words matched on a query.
+     * Surround words that match the query with HTML tags for highlighting.
      */
     _highlightResult?: Record<string, HighlightResult>;
     /**
-     * Snippeted attributes show parts of the matched attributes. Only returned when attributesToSnippet is non-empty.
+     * Snippets that show the context around a matching search query.
      */
     _snippetResult?: Record<string, SnippetResult>;
     _rankingInfo?: RankingInfo;

package/dist/lite/model/ignorePlurals.d.ts

@@ -1,5 +1,6 @@
+import type { SupportedLanguage } from './supportedLanguage';
 /**
- * Treats singular, plurals, and other forms of declensions as matching terms. `ignorePlurals` is used in conjunction with the `queryLanguages` setting. _list_: language ISO codes for which ignoring plurals should be enabled. This list will override any values that you may have set in `queryLanguages`. _true_: enables the ignore plurals feature, where singulars and plurals are considered equivalent (\"foot\" = \"feet\"). The languages supported here are either [every language](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/) (this is the default) or those set by `queryLanguages`. _false_: turns off the ignore plurals feature, so that singulars and plurals aren\'t considered to be the same (\"foot\" will not find \"feet\").
+ * Treat singular, plurals, and other forms of declensions as equivalent. You should only use this feature for the languages used in your index.
  */
-export type IgnorePlurals = string[] | boolean;
+export type IgnorePlurals = SupportedLanguage[] | boolean;
 //# sourceMappingURL=ignorePlurals.d.ts.map

package/dist/lite/model/ignorePlurals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ignorePlurals.d.ts","sourceRoot":"","sources":["../../../lite/model/ignorePlurals.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC"}
+{"version":3,"file":"ignorePlurals.d.ts","sourceRoot":"","sources":["../../../lite/model/ignorePlurals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,iBAAiB,EAAE,GAAG,OAAO,CAAC"}

package/dist/lite/model/index.d.ts

@@ -81,6 +81,7 @@ export * from './removeWordsIfNoResults';
 export * from './renderingContent';
 export * from './rule';
 export * from './scopeType';
+export * from './searchDictionaryEntriesResponse';
 export * from './searchForFacetValuesResponse';
 export * from './searchForFacets';
 export * from './searchForFacetsOptions';
@@ -107,6 +108,7 @@ export * from './snippetResultOption';
 export * from './sortRemainingBy';
 export * from './source';
 export * from './standardEntries';
+export * from './supportedLanguage';
 export * from './synonymHit';
 export * from './synonymType';
 export * from './tagFilters';