@wix/search 1.0.22 → 1.0.24

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

@@ -0,0 +1,749 @@
+interface SiteDocument {
+    /** @readonly */
+    _id?: string;
+    /** the document payload */
+    document?: Record<string, any> | null;
+}
+interface Search extends SearchPagingMethodOneOf {
+    /** Pointer to page of results using offset. Can not be used together with 'cursor_paging' */
+    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?: Record<string, any> | null;
+    /** Sort object in the form [{"fieldName":"sortField1"},{"fieldName":"sortField2","direction":"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. */
+    aggregations?: Aggregation$1[];
+    /** 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?: Paging;
+}
+interface Sorting {
+    /** Name of the field to sort by. */
+    fieldName?: string;
+    /** Sort order. */
+    order?: SortOrder;
+}
+declare enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+interface Aggregation$1 extends AggregationKindOneOf {
+    /** Value aggregation */
+    value?: ValueAggregation;
+    /** Scalar aggregation */
+    scalar?: ScalarAggregation;
+    /** Nested aggregation */
+    nested?: NestedAggregation;
+    /** User-defined name of aggregation, should be unique, will appear in aggregation results */
+    name?: string | null;
+    /** Type of aggregation, client must provide matching aggregation field below */
+    type?: AggregationType;
+    /** Field to aggregate by, use dot notation to specify json path */
+    fieldPath?: string;
+}
+/** @oneof */
+interface AggregationKindOneOf {
+    /** Value aggregation */
+    value?: ValueAggregation;
+    /** Scalar aggregation */
+    scalar?: ScalarAggregation;
+    /** Nested aggregation */
+    nested?: NestedAggregation;
+}
+declare enum ScalarType {
+    UNKNOWN_SCALAR_TYPE = "UNKNOWN_SCALAR_TYPE",
+    /** Minimum value */
+    MIN = "MIN",
+    /** Maximum value */
+    MAX = "MAX",
+    /** Sum of values */
+    SUM = "SUM"
+}
+declare enum NestedAggregationType {
+    UNKNOWN_AGGREGATION_TYPE = "UNKNOWN_AGGREGATION_TYPE",
+    /** An aggregation where result buckets are dynamically built - one per unique value */
+    VALUE = "VALUE",
+    /** A single-value metric aggregation - e.g. min, max, sum, avg */
+    SCALAR = "SCALAR"
+}
+interface ValueAggregation {
+    /** How many aggregations would you like to return? Can be between 1 and 250. 10 is the default. */
+    limit?: number | null;
+}
+interface ScalarAggregation {
+    /** Define the operator for the scalar aggregation */
+    type?: ScalarType;
+}
+interface NestedAggregationItem extends NestedAggregationItemKindOneOf {
+    /** Value aggregation */
+    value?: ValueAggregation;
+    /** Scalar aggregation */
+    scalar?: ScalarAggregation;
+    /** User-defined name of aggregation, should be unique, will appear in aggregation results */
+    name?: string | null;
+    /** Type of aggregation, client must provide matching aggregation field below */
+    type?: NestedAggregationType;
+    /** Field to aggregate by, use dont notation to specify json path */
+    fieldPath?: string;
+}
+/** @oneof */
+interface NestedAggregationItemKindOneOf {
+    /** Value aggregation */
+    value?: ValueAggregation;
+    /** Scalar aggregation */
+    scalar?: ScalarAggregation;
+}
+declare enum AggregationType {
+    UNKNOWN_AGGREGATION_TYPE = "UNKNOWN_AGGREGATION_TYPE",
+    /** An aggregation where result buckets are dynamically built - one per unique value */
+    VALUE = "VALUE",
+    /** A single-value metric aggregation - e.g. min, max, sum, avg */
+    SCALAR = "SCALAR",
+    /** Multi-level aggregation, where each next aggregation is nested within previous one */
+    NESTED = "NESTED"
+}
+/** 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 */
+    nestedAggregations?: NestedAggregationItem[];
+}
+interface SearchDetails {
+    /** 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?: string[];
+    /** Flag if should use auto fuzzy search (allowing typos by a managed proximity algorithm) */
+    fuzzy?: boolean;
+}
+interface Paging {
+    /** Number of items to load. */
+    limit?: number | null;
+    /** Number of items to skip in the current sort order. */
+    offset?: number | null;
+}
+declare enum DocumentType {
+    UNSPECIFIED = "UNSPECIFIED",
+    BLOG_POSTS = "BLOG_POSTS",
+    BOOKING_SERVICES = "BOOKING_SERVICES",
+    EVENTS = "EVENTS",
+    FORUM_CONTENT = "FORUM_CONTENT",
+    ONLINE_PROGRAMS = "ONLINE_PROGRAMS",
+    PROGALLERY_ITEM = "PROGALLERY_ITEM",
+    STORES_PRODUCTS = "STORES_PRODUCTS"
+}
+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 */
+    aggregationData?: AggregationData;
+}
+/** @oneof */
+interface SearchResponsePagingOneOf {
+    /** Paging metadata for the next page of results. */
+    pagingOffsetMetadata?: PagingMetadata;
+}
+interface AggregationData {
+    /** key = aggregation name (as derived from search request) */
+    results?: AggregationResults[];
+}
+interface ValueAggregationResult {
+    /** Value of the field */
+    value?: string;
+    count?: number;
+}
+interface ValueResults {
+    /** List of value aggregations */
+    results?: ValueAggregationResult[];
+}
+interface AggregationResultsScalarResult {
+    /** Type of scalar aggregation */
+    type?: ScalarType;
+    /** Value of the scalar aggregation */
+    value?: number;
+}
+interface ValueResult {
+    /** Value of the field */
+    value?: string;
+    /** Count of entities with this value */
+    count?: number | null;
+}
+interface ScalarResult {
+    /** Value of the scalar aggregation */
+    value?: number;
+}
+interface NestedResultValue extends NestedResultValueResultOneOf {
+    /** Value aggregation result */
+    value?: ValueResult;
+    /** Scalar aggregation result */
+    scalar?: ScalarResult;
+}
+/** @oneof */
+interface NestedResultValueResultOneOf {
+    /** Value aggregation result */
+    value?: ValueResult;
+    /** Scalar aggregation result */
+    scalar?: ScalarResult;
+}
+interface Results {
+    /** List of nested aggregations */
+    results?: Record<string, NestedResultValue>;
+}
+/**
+ * Results of `NESTED` aggregation type in a flattened form
+ * aggregations in resulting array are keyed by requested aggregation `name`.
+ */
+interface NestedResults {
+    /** List of nested aggregations */
+    results?: Results[];
+}
+interface AggregationResults extends AggregationResultsResultOneOf {
+    /** Value aggregation results */
+    values?: ValueResults;
+    /** Scalar aggregation results */
+    scalar?: AggregationResultsScalarResult;
+    /** Nested aggregation results */
+    nested?: NestedResults;
+    /** User-defined name of aggregation as derived from search request */
+    name?: string;
+    /** Type of aggregation that must match provided kind as derived from search request */
+    type?: AggregationType;
+    /** Field to aggregate by as derived from search request */
+    fieldPath?: string;
+}
+/** @oneof */
+interface AggregationResultsResultOneOf {
+    /** Value aggregation results */
+    values?: ValueResults;
+    /** Scalar aggregation results */
+    scalar?: AggregationResultsScalarResult;
+    /** Nested aggregation results */
+    nested?: NestedResults;
+}
+interface PagingMetadata {
+    /** Number of items returned in the response. */
+    count?: number | null;
+    /** Offset that was requested. */
+    offset?: number | null;
+    /** Total number of items that match the query. */
+    total?: number | null;
+    /** Flag that indicates the server failed to calculate the `total` field. */
+    tooManyToCount?: boolean | null;
+}
+interface SearchResponseNonNullableFields$1 {
+    siteDocuments: {
+        _id: string;
+    }[];
+    aggregationData?: {
+        results: {
+            values?: {
+                results: {
+                    value: string;
+                    count: number;
+                }[];
+            };
+            scalar?: {
+                type: ScalarType;
+                value: number;
+            };
+            nested?: {
+                results: {
+                    results?: {
+                        value?: {
+                            value: string;
+                        };
+                        scalar?: {
+                            value: number;
+                        };
+                    };
+                }[];
+            };
+            name: string;
+            type: AggregationType;
+            fieldPath: string;
+        }[];
+    };
+}
+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;
+}
+
+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>>;
+}
+type RequestOptionsFactory<TResponse = any, TData = any> = (context: any) => RequestOptions<TResponse, TData>;
+type HttpResponse<T = any> = {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    request?: any;
+};
+type RequestOptions<_TResponse = any, Data = any> = {
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    url: string;
+    data?: Data;
+    params?: URLSearchParams;
+} & APIMetadata;
+type APIMetadata = {
+    methodFqn?: string;
+    entityFqdn?: string;
+    packageName?: string;
+};
+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 const search$2: BuildRESTFunction<typeof search$3>;
+
+declare namespace context$1 {
+  export { search$2 as search };
+}
+
+interface OrderingClauses {
+    ordering?: OrderingClause[];
+}
+interface OrderingClause {
+    fieldName?: string | null;
+    direction?: Direction;
+}
+declare enum Direction {
+    UninitializedDirection = "UninitializedDirection",
+    ASC = "ASC",
+    DESC = "DESC"
+}
+interface SearchPaging {
+    /**
+     * Number of items to skip in the result set.
+     * @deprecated
+     */
+    skip?: number;
+    /** Number of items to fetch (effectively page size). */
+    limit?: number;
+    /** Number of items to skip in the result set. */
+    offset?: number;
+}
+interface FacetClauses {
+    /** Each entry represents a single facet with parameters. */
+    clauses?: FacetClause[];
+}
+interface FacetClause extends FacetClauseClauseOneOf {
+    term?: TermFacet;
+    aggregation?: AggregationFacet;
+    hierarchical?: HierarchicalFacet;
+}
+/** @oneof */
+interface FacetClauseClauseOneOf {
+    term?: TermFacet;
+    aggregation?: AggregationFacet;
+    hierarchical?: HierarchicalFacet;
+}
+declare enum Aggregation {
+    MIN = "MIN",
+    MAX = "MAX",
+    SUM = "SUM"
+}
+interface HierarchicalFacet extends HierarchicalFacetClauseOneOf {
+    term?: TermFacet;
+    aggregation?: AggregationFacet;
+    nestedAggregation?: HierarchicalFacet;
+}
+/** @oneof */
+interface HierarchicalFacetClauseOneOf {
+    term?: TermFacet;
+    aggregation?: AggregationFacet;
+}
+interface TermFacet {
+    /** The name of the faceted attribute. */
+    name?: string;
+    /** Limit the number of facet values returned. Default is 10. */
+    limit?: number | null;
+}
+interface AggregationFacet {
+    /** The name of the faceted attribute. */
+    name?: string;
+    /** Aggregation type. */
+    aggregation?: Aggregation;
+}
+interface SearchProperty {
+    name?: string;
+    value?: any;
+}
+interface SearchResponse {
+    /** Documents matching filter and query. */
+    documents?: Record<string, any>[] | null;
+    nextPage?: NextPageResponse;
+    /**
+     * Facets provide "counts in categories" view. For example searching for "Nike" would return
+     * (Shoes, 5), (Socks, 2) indicating numbers for matching by each faceted field.
+     */
+    facets?: FacetsResponse[];
+}
+interface NextPageResponse {
+    /** Total number of items across all pages */
+    total?: number;
+    /** The number of items to skip */
+    skip?: number;
+    /** The number of items to retrieve in one page */
+    limit?: number;
+}
+interface FacetsResponse extends FacetsResponseResponseOneOf {
+    terms?: TermAggregationResponse;
+    minAggregation?: MinAggregationResponse;
+    maxAggregation?: MaxAggregationResponse;
+    minMaxAggregation?: MinMaxAggregationResponse;
+    hierarchicalAggregation?: HierarchicalAggregationResponse;
+    sumAggregation?: SumAggregationResponse;
+}
+/** @oneof */
+interface FacetsResponseResponseOneOf {
+    terms?: TermAggregationResponse;
+    minAggregation?: MinAggregationResponse;
+    maxAggregation?: MaxAggregationResponse;
+    minMaxAggregation?: MinMaxAggregationResponse;
+    hierarchicalAggregation?: HierarchicalAggregationResponse;
+    sumAggregation?: SumAggregationResponse;
+}
+interface FacetCountResponse {
+    /** Facet field value (for example "Shoes", "Socks") */
+    facetValue?: string;
+    /** Document count within the group */
+    count?: number;
+}
+interface Value {
+    value?: string;
+    facets?: FacetsResponse;
+    count?: number;
+}
+interface TermAggregationResponse {
+    /** Facet field (for example productCategory) */
+    facet?: string;
+    /** Facet values and document counts */
+    facets?: FacetCountResponse[];
+}
+interface MinAggregationResponse {
+    /** Facet field (for example productPrice) */
+    facet?: string;
+    /** The minimum value across all documents */
+    minValue?: number | null;
+}
+interface MaxAggregationResponse {
+    /** Facet field (for example productPrice) */
+    facet?: string;
+    /** The maximum value across all documents */
+    maxValue?: number | null;
+}
+interface MinMaxAggregationResponse {
+    /** Facet field (for example productPrice) */
+    facet?: string;
+    /** The minimum value across all documents */
+    minValue?: number | null;
+    /** The maximum value across all documents */
+    maxValue?: number | null;
+}
+interface HierarchicalAggregationResponse {
+    facet?: string;
+    values?: Value[];
+}
+interface SumAggregationResponse {
+    /** Facet field (for example productPrice) */
+    facet?: string;
+    /** 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;
+        skip: number;
+        limit: number;
+    };
+    facets: {
+        terms?: {
+            facet: string;
+            facets: {
+                facetValue: string;
+                count: number;
+            }[];
+        };
+        minAggregation?: {
+            facet: string;
+        };
+        maxAggregation?: {
+            facet: string;
+        };
+        minMaxAggregation?: {
+            facet: string;
+        };
+        hierarchicalAggregation?: {
+            facet: string;
+            values: {
+                value: string;
+                count: number;
+            }[];
+        };
+        sumAggregation?: {
+            facet: string;
+        };
+    }[];
+}
+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;
+    /** Document type of documents to search for. All document types are searched if not provided. */
+    documentType?: string | null;
+    /** Fields to order by. */
+    ordering?: OrderingClauses;
+    /** Paging parameters. */
+    paging?: SearchPaging;
+    /** Language to search in. */
+    language?: string | null;
+    /** Filter in platformized query language (for example {'field': {'$eq': 'value'}}) */
+    filter?: Record<string, any> | null;
+    /** The facets to retrieve. */
+    facets?: FacetClauses;
+    /** Enable fuzzy search (eg. 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 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[];
+    /** 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 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_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 };