@wix/search 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/search",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -18,11 +18,10 @@
     "type-bundles"
   ],
   "dependencies": {
-    "@wix/search_site-search": "1.0.16",
-    "@wix/search_wix-site-search": "1.0.3"
+    "@wix/search_site-search": "1.0.18",
+    "@wix/search_wix-site-search": "1.0.4"
   },
   "devDependencies": {
-    "@wix/sdk": "https://cdn.dev.wixpress.com/@wix/sdk/02e8069ab2fd783e0e6a080fc7d590e76cb26ab93c8389574286305b.tar.gz",
     "glob": "^10.4.1",
     "rollup": "^4.18.0",
     "rollup-plugin-dts": "^6.1.1",
@@ -44,5 +43,5 @@
       "fqdn": ""
     }
   },
-  "falconPackageHash": "50c655179c40e58c84d4cee0ed209565b35897cb3a396e89bbeff810"
+  "falconPackageHash": "469ebc4218260f95acc4f48c4ae5a57a5c02452aa071e276ae639f4a"
 }

package/type-bundles/context.bundle.d.ts

@@ -1,24 +1,40 @@
 interface SiteDocument {
-    /** @readonly */
+    /**
+     * Results ID.
+     * @readonly
+     */
     _id?: string;
-    /** the document payload */
-    document?: Record<string, any> | null;
+    /** The docuement payload. */
+    data?: Record<string, any> | null;
 }
 interface Search extends SearchPagingMethodOneOf {
-    /** Pointer to page of results using offset. Can not be used together with 'cursor_paging' */
+    /** Paging options to limit and skip the number of items. */
     paging?: Paging;
-    /** A filter object. See documentation [here](https://bo.wix.com/wix-docs/rnd/platformization-guidelines/api-query-language#platformization-guidelines_api-query-language_defining-in-protobuf) */
+    /**
+     * Filter object in the following format:
+     * `"filter" : {
+     * "fieldName1": "value1",
+     * "fieldName2":{"$operator":"value2"}
+     * }`
+     * Example of operators: `$eq`, `$ne`, `$lt`, `$lte`, `$gt`, `$gte`, `$in`, `$hasSome`, `$hasAll`, `$startsWith`, `$contains`
+     */
     filter?: Record<string, any> | null;
-    /** Sort object in the form [{"fieldName":"sortField1"},{"fieldName":"sortField2","direction":"DESC"}] */
+    /**
+     * Sort object in the following format:
+     * `[{"fieldName":"sortField1","order":"ASC"},{"fieldName":"sortField2","order":"DESC"}]`
+     */
     sort?: Sorting[];
-    /** Aggregations | Faceted search: refers to a way to explore large amounts of data by displaying summaries about various partitions of the data and later allowing to narrow the navigation to a specific partition. */
+    /**
+     * A search method for grouping data into various categories (facets) and providing summaries for each category.
+     * For example, use aggregations to allow site visitors to narrow down their search results by selecting specific categories such as price ranges, brand names, and ratings.
+     */
     aggregations?: Aggregation$1[];
-    /** Free text to match in searchable fields */
+    /** Free text to match in searchable fields. */
     search?: SearchDetails;
 }
 /** @oneof */
 interface SearchPagingMethodOneOf {
-    /** Pointer to page of results using offset. Can not be used together with 'cursor_paging' */
+    /** Paging options to limit and skip the number of items. */
     paging?: Paging;
 }
 interface Sorting {
@@ -32,26 +48,32 @@ declare enum SortOrder {
     DESC = "DESC"
 }
 interface Aggregation$1 extends AggregationKindOneOf {
-    /** Value aggregation */
+    /** A value aggregation calculates metrics such as count for specific fields within a dataset, providing insights into the overall distribution and key statistics of those values. For example, use a value aggregation to get the number of products (count) for each price listed in the store. */
     value?: ValueAggregation;
-    /** Scalar aggregation */
+    /** A scalar aggregation calculates a single numerical value from a dataset, such as the total sum, average, min, or max, summarizing the dataset into one key metric. For example, use a scalar aggregation to get the minimum price listed in the store. */
     scalar?: ScalarAggregation;
-    /** Nested aggregation */
+    /**
+     * A nested aggregation is applied within the results of another aggregation. Rather than aggregating directly on the primary dataset, first group data using one aggregation and then apply another aggregation within each group. It allows for more complex analyses where you can summarize data at different levels of detail or hierarchy.
+     * For example, to get the number of products that are in stock and out of stock for each price listed, first perform a value aggregation on `discountedPriceNumeric`, and a second value aggregation on `inStock`.
+     */
     nested?: NestedAggregation;
-    /** User-defined name of aggregation, should be unique, will appear in aggregation results */
+    /** Aggregation name displayed in the return. */
     name?: string | null;
-    /** Type of aggregation, client must provide matching aggregation field below */
+    /** Type of aggregation to perform. */
     type?: AggregationType;
-    /** Field to aggregate by, use dot notation to specify json path */
+    /** Field to aggregate by. */
     fieldPath?: string;
 }
 /** @oneof */
 interface AggregationKindOneOf {
-    /** Value aggregation */
+    /** A value aggregation calculates metrics such as count for specific fields within a dataset, providing insights into the overall distribution and key statistics of those values. For example, use a value aggregation to get the number of products (count) for each price listed in the store. */
     value?: ValueAggregation;
-    /** Scalar aggregation */
+    /** A scalar aggregation calculates a single numerical value from a dataset, such as the total sum, average, min, or max, summarizing the dataset into one key metric. For example, use a scalar aggregation to get the minimum price listed in the store. */
     scalar?: ScalarAggregation;
-    /** Nested aggregation */
+    /**
+     * A nested aggregation is applied within the results of another aggregation. Rather than aggregating directly on the primary dataset, first group data using one aggregation and then apply another aggregation within each group. It allows for more complex analyses where you can summarize data at different levels of detail or hierarchy.
+     * For example, to get the number of products that are in stock and out of stock for each price listed, first perform a value aggregation on `discountedPriceNumeric`, and a second value aggregation on `inStock`.
+     */
     nested?: NestedAggregation;
 }
 declare enum ScalarType {
@@ -71,30 +93,35 @@ declare enum NestedAggregationType {
     SCALAR = "SCALAR"
 }
 interface ValueAggregation {
-    /** How many aggregations would you like to return? Can be between 1 and 250. 10 is the default. */
+    /**
+     * Number of aggregation results to return.
+     * Min: `1`
+     * Max: `250`
+     * Default: `10`
+     */
     limit?: number | null;
 }
 interface ScalarAggregation {
-    /** Define the operator for the scalar aggregation */
+    /** Operation type for the scalar aggregation. */
     type?: ScalarType;
 }
 interface NestedAggregationItem extends NestedAggregationItemKindOneOf {
-    /** Value aggregation */
+    /** A value aggregation calculates metrics such as count for specific fields within a dataset, providing insights into the overall distribution and key statistics of those values. For example, use a value aggregation to get the number of products (count) for each price listed in the store. */
     value?: ValueAggregation;
-    /** Scalar aggregation */
+    /** A scalar aggregation calculates a single numerical value from a dataset, such as the total sum, average, min, or max, summarizing the dataset into one key metric. For example, use a scalar aggregation to get the minimum price listed in the store. */
     scalar?: ScalarAggregation;
-    /** User-defined name of aggregation, should be unique, will appear in aggregation results */
+    /** Aggregation name displayed in the return. */
     name?: string | null;
-    /** Type of aggregation, client must provide matching aggregation field below */
+    /** Type of aggregation to perform. */
     type?: NestedAggregationType;
-    /** Field to aggregate by, use dont notation to specify json path */
+    /** Field to aggregate by. */
     fieldPath?: string;
 }
 /** @oneof */
 interface NestedAggregationItemKindOneOf {
-    /** Value aggregation */
+    /** A value aggregation calculates metrics such as count for specific fields within a dataset, providing insights into the overall distribution and key statistics of those values. For example, use a value aggregation to get the number of products (count) for each price listed in the store. */
     value?: ValueAggregation;
-    /** Scalar aggregation */
+    /** A scalar aggregation calculates a single numerical value from a dataset, such as the total sum, average, min, or max, summarizing the dataset into one key metric. For example, use a scalar aggregation to get the minimum price listed in the store. */
     scalar?: ScalarAggregation;
 }
 declare enum AggregationType {
@@ -108,15 +135,21 @@ declare enum AggregationType {
 }
 /** Nested aggregation expressed through a list of aggregation where each next aggregation is nested within previous one */
 interface NestedAggregation {
-    /** Flattened list of aggregations, where each next aggregation is nested within previous one */
+    /** Flattened list of aggregations, where each aggregation is nested within previous one. */
     nestedAggregations?: NestedAggregationItem[];
 }
 interface SearchDetails {
-    /** Search term or expression */
+    /** Search term or expression. */
     expression?: string | null;
-    /** Fields to search in. If empty - will search in all searchable fields. Use dot notation to specify json path */
+    /**
+     * Fields to search in.
+     * If the array is empty, all fields are searched.
+     */
     fields?: string[];
-    /** Flag if should use auto fuzzy search (allowing typos by a managed proximity algorithm) */
+    /**
+     * Whether to allow the search function to automatically correct typos or minor mistakes in the search expression.
+     * The search function uses an algorithm to find results that are close to what the site visitor typed.
+     */
     fuzzy?: boolean;
 }
 interface Paging {
@@ -138,9 +171,9 @@ declare enum DocumentType {
 interface SearchResponse$1 extends SearchResponsePagingOneOf {
     /** Paging metadata for the next page of results. */
     pagingOffsetMetadata?: PagingMetadata;
-    /** Documents matching filter and query. */
-    siteDocuments?: SiteDocument[];
-    /** Response aggregation data */
+    /** Documents matching the search query. */
+    siteDocumentItems?: SiteDocument[];
+    /** Aggregated data. */
     aggregationData?: AggregationData;
 }
 /** @oneof */
@@ -149,7 +182,7 @@ interface SearchResponsePagingOneOf {
     pagingOffsetMetadata?: PagingMetadata;
 }
 interface AggregationData {
-    /** key = aggregation name (as derived from search request) */
+    /** List of the aggregated data results. */
     results?: AggregationResults[];
 }
 interface ValueAggregationResult {
@@ -174,24 +207,24 @@ interface ValueResult {
     count?: number | null;
 }
 interface ScalarResult {
-    /** Value of the scalar aggregation */
+    /** Scalar aggregation results. */
     value?: number;
 }
 interface NestedResultValue extends NestedResultValueResultOneOf {
-    /** Value aggregation result */
+    /** Value aggregation results. */
     value?: ValueResult;
-    /** Scalar aggregation result */
+    /** Scalar aggregation results. */
     scalar?: ScalarResult;
 }
 /** @oneof */
 interface NestedResultValueResultOneOf {
-    /** Value aggregation result */
+    /** Value aggregation results. */
     value?: ValueResult;
-    /** Scalar aggregation result */
+    /** Scalar aggregation results. */
     scalar?: ScalarResult;
 }
 interface Results {
-    /** List of nested aggregations */
+    /** List of nested aggregation results. */
     results?: Record<string, NestedResultValue>;
 }
 /**
@@ -199,30 +232,30 @@ interface Results {
  * aggregations in resulting array are keyed by requested aggregation `name`.
  */
 interface NestedResults {
-    /** List of nested aggregations */
+    /** List of nested aggregation results. */
     results?: Results[];
 }
 interface AggregationResults extends AggregationResultsResultOneOf {
-    /** Value aggregation results */
+    /** Value aggregation results. */
     values?: ValueResults;
-    /** Scalar aggregation results */
+    /** Scalar aggregation results. */
     scalar?: AggregationResultsScalarResult;
-    /** Nested aggregation results */
+    /** Nested aggregation results. */
     nested?: NestedResults;
-    /** User-defined name of aggregation as derived from search request */
+    /** Aggregation name defined in the request. */
     name?: string;
-    /** Type of aggregation that must match provided kind as derived from search request */
+    /** Type of aggregation that was performed. */
     type?: AggregationType;
-    /** Field to aggregate by as derived from search request */
+    /** Field the data was aggregated by. */
     fieldPath?: string;
 }
 /** @oneof */
 interface AggregationResultsResultOneOf {
-    /** Value aggregation results */
+    /** Value aggregation results. */
     values?: ValueResults;
-    /** Scalar aggregation results */
+    /** Scalar aggregation results. */
     scalar?: AggregationResultsScalarResult;
-    /** Nested aggregation results */
+    /** Nested aggregation results. */
     nested?: NestedResults;
 }
 interface PagingMetadata {
@@ -236,7 +269,7 @@ interface PagingMetadata {
     tooManyToCount?: boolean | null;
 }
 interface SearchResponseNonNullableFields$1 {
-    siteDocuments: {
+    siteDocumentItems: {
         _id: string;
     }[];
     aggregationData?: {
@@ -270,15 +303,14 @@ interface SearchResponseNonNullableFields$1 {
     };
 }
 interface SearchOptions$1 {
-    /** Document type of documents to search for. All document types are searched if not provided. */
-    documentType: DocumentType;
-    /** Language to search in. */
-    language?: string | null;
+    /** Search query and aggregation information. */
+    search: Search;
 }
 
 type RESTFunctionDescriptor<T extends (...args: any[]) => any = (...args: any[]) => any> = (httpClient: HttpClient) => T;
 interface HttpClient {
     request<TResponse, TData = any>(req: RequestOptionsFactory<TResponse, TData>): Promise<HttpResponse<TResponse>>;
+    fetchWithAuth: (url: string | URL, init?: RequestInit) => Promise<Response>;
 }
 type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
 type HttpResponse<T = any> = {
@@ -301,7 +333,14 @@ type APIMetadata = {
 };
 type BuildRESTFunction<T extends RESTFunctionDescriptor> = T extends RESTFunctionDescriptor<infer U> ? U : never;
 
-declare function search$3(httpClient: HttpClient): (search: Search, options?: SearchOptions$1) => Promise<SearchResponse$1 & SearchResponseNonNullableFields$1>;
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+declare function search$3(httpClient: HttpClient): (documentType: DocumentType, language: string | null, options: SearchOptions$1) => Promise<SearchResponse$1 & SearchResponseNonNullableFields$1>;
 
 declare const search$2: BuildRESTFunction<typeof search$3>;
 
@@ -460,6 +499,61 @@ interface SumAggregationResponse {
     /** The sum value across all documents */
     value?: number | null;
 }
+interface FederatedSearchResponse {
+    /** Search results from multiple indexes. */
+    results?: FederatedSearchDocuments[];
+}
+interface FederatedSearchDocuments {
+    /** Document type of documents */
+    documentType?: string | null;
+    /** Documents of document type */
+    documents?: Record<string, any>[] | null;
+    /** Total count of matching documents for document type */
+    total?: number;
+}
+interface SuggestResponse {
+    /** Suggested documents. */
+    documents?: Record<string, any>[] | null;
+}
+interface FederatedSuggestResponse {
+    /** Suggest results from multiple indexes. */
+    results?: FederatedSuggestDocuments[];
+}
+interface FederatedSuggestDocuments {
+    /** Document type of documents */
+    documentType?: string | null;
+    /** Documents of document type */
+    documents?: Record<string, any>[] | null;
+}
+interface RelatedResponse {
+    /** Documents matching filter and query. */
+    documents?: Record<string, any>[] | null;
+}
+interface AutocompleteResponse {
+    /** Suggested phrases. */
+    values?: AutocompleteResponseValue[];
+}
+interface AutocompleteResponseValue {
+    /** Suggested phrase. */
+    query?: string;
+}
+interface FederatedAutocompleteResponse {
+    /** Suggested phrases from multiple indexes */
+    results?: FederatedAutocompleteResults[];
+}
+interface FederatedAutocompleteResults {
+    /** Document type of queries */
+    documentType?: string | null;
+    /** Suggested phrases */
+    values?: AutocompleteResponseValue[];
+}
+interface TrendingResponse {
+    results?: TrendingItems[];
+}
+interface TrendingItems {
+    documentType?: string;
+    documents?: Record<string, any>[] | null;
+}
 interface SearchResponseNonNullableFields {
     nextPage?: {
         total: number;
@@ -495,6 +589,31 @@ interface SearchResponseNonNullableFields {
         };
     }[];
 }
+interface FederatedSearchResponseNonNullableFields {
+    results: {
+        total: number;
+    }[];
+}
+interface FederatedSuggestResponseNonNullableFields {
+    results: FederatedSuggestDocuments[];
+}
+interface AutocompleteResponseNonNullableFields {
+    values: {
+        query: string;
+    }[];
+}
+interface FederatedAutocompleteResponseNonNullableFields {
+    results: {
+        values: {
+            query: string;
+        }[];
+    }[];
+}
+interface TrendingResponseNonNullableFields {
+    results: {
+        documentType: string;
+    }[];
+}
 interface SearchOptions {
     /** Text to search for. All searchable fields will be searched. */
     query?: string | null;
@@ -523,14 +642,147 @@ interface SearchOptions {
     /** Include seo hidden documents. Defaults to false if not provided. */
     includeSeoHidden?: boolean | null;
 }
+interface FederatedSearchOptions {
+    /** Query phrase to use. */
+    query?: string | null;
+    /** Language to search in. */
+    language?: string | null;
+    /** Limit of documents to return per document type. */
+    limit?: number | null;
+    /** Enable fuzzy search (for example query 'kalvin clein' will match document with 'calvin klein' in title). */
+    fuzzy?: boolean | null;
+    /** Highlight texts matching the query. Highlighted text will be wrapped with <mark/> tag. Defaults to true if not provided. */
+    highlight?: boolean | null;
+    /** Searchable fields to search in. If not provided, search is executed on all searchable fields in schemas */
+    searchFields?: string[];
+    /** Document types to search in. If not provided, search is executed on all document types enabled for the site */
+    documentTypes?: string[];
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+}
+interface SuggestOptions {
+    /** Text to search for. Fields configured in suggester configuration will be searched. */
+    query?: string | null;
+    /** Document type of documents to search for. All document types are searched if not provided. */
+    documentType?: string | null;
+    /** Fields to order by. */
+    ordering?: OrderingClauses;
+    /** Number of suggested document to return. */
+    limit?: number;
+    /** Language to search in. */
+    language?: string | null;
+    /** Filter in platformized query language (for example {'field': {'$eq': 'value'}}) */
+    filter?: Record<string, any> | null;
+    /** Searchable fields to search in. If not provided, search is executed on all suggestable fields in schema */
+    searchFields?: string[];
+    /** A list of fields to include in the result set. If not provided, all fields of schema will be included. */
+    fields?: string[];
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+    /** The properties/overrides/experiments to enable for this request. Currently supported: `scoring_profile`. */
+    properties?: SearchProperty[];
+}
+interface FederatedSuggestOptions {
+    /** Text to search for. Fields configured in suggester configuration will be searched. */
+    query?: string | null;
+    /** Language to search in. */
+    language?: string | null;
+    /** Number of suggested document to return per document type. */
+    limit?: number;
+    /** Searchable fields to search in. If not provided, search is executed on all suggestable fields in schemas */
+    searchFields?: string[];
+    /** Document types to search in. If not provided, search is executed on all document types enabled for the site */
+    documentTypes?: string[];
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+}
+interface RelatedOptions {
+    /** ID of the document to fetch related documents for. */
+    documentId?: string | null;
+    /** Document type of the document. */
+    documentType?: string | null;
+    /** Fields to order by. */
+    ordering?: OrderingClauses;
+    /** Language to search in. */
+    language?: string | null;
+    /** Filter in platformized query language (for example {'field': {'$eq': 'value'}}). */
+    filter?: Record<string, any> | null;
+    /** Searchable fields to compare documents by. If not provided, all searchable fields in schema are used */
+    searchFields?: string[];
+    /** A list of fields to include in the result set. If not provided, all fields of schema will be included. */
+    fields?: string[];
+    /** Number of related documents to return */
+    limit?: number;
+    /** The properties/overrides/experiments to enable for this request. Currently supported: `scoring_profile`. */
+    properties?: SearchProperty[];
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+}
+interface AutocompleteOptions {
+    /** Query phrase to fetch completions for. */
+    query?: string | null;
+    /** Document type to use to search for phrases. */
+    documentType?: string | null;
+    /** Limit of phrases to fetch. */
+    limit?: number;
+    /** Language to search in. */
+    language?: string | null;
+    /** Filter in platfromized query language (for example {'field': {'$eq': 'value'}}) */
+    filter?: Record<string, any> | null;
+    /** Searchable fields to use for query completion. If not provided, all searchable fields in schema are used */
+    searchFields?: string[];
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+}
+interface FederatedAutocompleteOptions {
+    /** Query phrase to fetch completions for. */
+    query?: string | null;
+    /** Language to search in. */
+    language?: string | null;
+    /** Number of queries to return per document type. */
+    limit?: number;
+    /** Searchable fields to search in. If not provided, search is executed on all autocompletable fields in schemas */
+    searchFields?: string[];
+    /** Document types to autocomplete in. If not provided, autocomplete is executed on all document types enabled for the site */
+    documentTypes?: string[];
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+}
+interface TrendingOptions {
+    documentTypes?: string[];
+    language?: string | null;
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+}
 
 declare function search$1(httpClient: HttpClient): (options?: SearchOptions) => Promise<SearchResponse & SearchResponseNonNullableFields>;
+declare function federatedSearch$1(httpClient: HttpClient): (options?: FederatedSearchOptions) => Promise<FederatedSearchResponse & FederatedSearchResponseNonNullableFields>;
+declare function suggest$1(httpClient: HttpClient): (options?: SuggestOptions) => Promise<SuggestResponse>;
+declare function federatedSuggest$1(httpClient: HttpClient): (options?: FederatedSuggestOptions) => Promise<FederatedSuggestResponse & FederatedSuggestResponseNonNullableFields>;
+declare function related$1(httpClient: HttpClient): (options?: RelatedOptions) => Promise<RelatedResponse>;
+declare function autocomplete$1(httpClient: HttpClient): (options?: AutocompleteOptions) => Promise<AutocompleteResponse & AutocompleteResponseNonNullableFields>;
+declare function federatedAutocomplete$1(httpClient: HttpClient): (options?: FederatedAutocompleteOptions) => Promise<FederatedAutocompleteResponse & FederatedAutocompleteResponseNonNullableFields>;
+declare function trending$1(httpClient: HttpClient): (options?: TrendingOptions) => Promise<TrendingResponse & TrendingResponseNonNullableFields>;
 
 declare const search: BuildRESTFunction<typeof search$1>;
+declare const federatedSearch: BuildRESTFunction<typeof federatedSearch$1>;
+declare const suggest: BuildRESTFunction<typeof suggest$1>;
+declare const federatedSuggest: BuildRESTFunction<typeof federatedSuggest$1>;
+declare const related: BuildRESTFunction<typeof related$1>;
+declare const autocomplete: BuildRESTFunction<typeof autocomplete$1>;
+declare const federatedAutocomplete: BuildRESTFunction<typeof federatedAutocomplete$1>;
+declare const trending: BuildRESTFunction<typeof trending$1>;
 
+declare const context_autocomplete: typeof autocomplete;
+declare const context_federatedAutocomplete: typeof federatedAutocomplete;
+declare const context_federatedSearch: typeof federatedSearch;
+declare const context_federatedSuggest: typeof federatedSuggest;
+declare const context_related: typeof related;
 declare const context_search: typeof search;
+declare const context_suggest: typeof suggest;
+declare const context_trending: typeof trending;
 declare namespace context {
-  export { context_search as search };
+  export { context_autocomplete as autocomplete, context_federatedAutocomplete as federatedAutocomplete, context_federatedSearch as federatedSearch, context_federatedSuggest as federatedSuggest, context_related as related, context_search as search, context_suggest as suggest, context_trending as trending };
 }
 
 export { context as siteSearch, context$1 as wixSiteSearch };