@wix/search 1.0.21 → 1.0.23

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

@@ -0,0 +1,1101 @@
+interface SiteDocument$1 {
+    /** @readonly */
+    _id?: string;
+    /** the document payload */
+    document?: Record<string, any> | null;
+}
+interface SearchRequest$1 {
+    /** Search query */
+    search: Search;
+    /** Document type of documents to search for. All document types are searched if not provided. */
+    documentType: DocumentType;
+    /** Language to search in. */
+    language?: string | 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$1[];
+    /** 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;
+}
+
+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;
+};
+
+declare const __metadata$1: {
+    PACKAGE_NAME: string;
+};
+declare function search$1(httpClient: HttpClient): (search: Search, options?: SearchOptions$1) => Promise<SearchResponse$1 & SearchResponseNonNullableFields$1>;
+
+type index_d$1_AggregationData = AggregationData;
+type index_d$1_AggregationKindOneOf = AggregationKindOneOf;
+type index_d$1_AggregationResults = AggregationResults;
+type index_d$1_AggregationResultsResultOneOf = AggregationResultsResultOneOf;
+type index_d$1_AggregationResultsScalarResult = AggregationResultsScalarResult;
+type index_d$1_AggregationType = AggregationType;
+declare const index_d$1_AggregationType: typeof AggregationType;
+type index_d$1_DocumentType = DocumentType;
+declare const index_d$1_DocumentType: typeof DocumentType;
+type index_d$1_NestedAggregation = NestedAggregation;
+type index_d$1_NestedAggregationItem = NestedAggregationItem;
+type index_d$1_NestedAggregationItemKindOneOf = NestedAggregationItemKindOneOf;
+type index_d$1_NestedAggregationType = NestedAggregationType;
+declare const index_d$1_NestedAggregationType: typeof NestedAggregationType;
+type index_d$1_NestedResultValue = NestedResultValue;
+type index_d$1_NestedResultValueResultOneOf = NestedResultValueResultOneOf;
+type index_d$1_NestedResults = NestedResults;
+type index_d$1_Paging = Paging;
+type index_d$1_PagingMetadata = PagingMetadata;
+type index_d$1_Results = Results;
+type index_d$1_ScalarAggregation = ScalarAggregation;
+type index_d$1_ScalarResult = ScalarResult;
+type index_d$1_ScalarType = ScalarType;
+declare const index_d$1_ScalarType: typeof ScalarType;
+type index_d$1_Search = Search;
+type index_d$1_SearchDetails = SearchDetails;
+type index_d$1_SearchPagingMethodOneOf = SearchPagingMethodOneOf;
+type index_d$1_SearchResponsePagingOneOf = SearchResponsePagingOneOf;
+type index_d$1_SortOrder = SortOrder;
+declare const index_d$1_SortOrder: typeof SortOrder;
+type index_d$1_Sorting = Sorting;
+type index_d$1_ValueAggregation = ValueAggregation;
+type index_d$1_ValueAggregationResult = ValueAggregationResult;
+type index_d$1_ValueResult = ValueResult;
+type index_d$1_ValueResults = ValueResults;
+declare namespace index_d$1 {
+  export { type Aggregation$1 as Aggregation, type index_d$1_AggregationData as AggregationData, type index_d$1_AggregationKindOneOf as AggregationKindOneOf, type index_d$1_AggregationResults as AggregationResults, type index_d$1_AggregationResultsResultOneOf as AggregationResultsResultOneOf, type index_d$1_AggregationResultsScalarResult as AggregationResultsScalarResult, index_d$1_AggregationType as AggregationType, index_d$1_DocumentType as DocumentType, type index_d$1_NestedAggregation as NestedAggregation, type index_d$1_NestedAggregationItem as NestedAggregationItem, type index_d$1_NestedAggregationItemKindOneOf as NestedAggregationItemKindOneOf, index_d$1_NestedAggregationType as NestedAggregationType, type index_d$1_NestedResultValue as NestedResultValue, type index_d$1_NestedResultValueResultOneOf as NestedResultValueResultOneOf, type index_d$1_NestedResults as NestedResults, type index_d$1_Paging as Paging, type index_d$1_PagingMetadata as PagingMetadata, type index_d$1_Results as Results, type index_d$1_ScalarAggregation as ScalarAggregation, type index_d$1_ScalarResult as ScalarResult, index_d$1_ScalarType as ScalarType, type index_d$1_Search as Search, type index_d$1_SearchDetails as SearchDetails, type SearchOptions$1 as SearchOptions, type index_d$1_SearchPagingMethodOneOf as SearchPagingMethodOneOf, type SearchRequest$1 as SearchRequest, type SearchResponse$1 as SearchResponse, type SearchResponseNonNullableFields$1 as SearchResponseNonNullableFields, type index_d$1_SearchResponsePagingOneOf as SearchResponsePagingOneOf, type SiteDocument$1 as SiteDocument, index_d$1_SortOrder as SortOrder, type index_d$1_Sorting as Sorting, type index_d$1_ValueAggregation as ValueAggregation, type index_d$1_ValueAggregationResult as ValueAggregationResult, type index_d$1_ValueResult as ValueResult, type index_d$1_ValueResults as ValueResults, __metadata$1 as __metadata, search$1 as search };
+}
+
+/** API is not yet fully migrated to FQDN entity */
+interface SiteDocument {
+    /** the document payload */
+    document?: Record<string, any> | null;
+}
+interface UpdateInternalDocumentsEvent extends UpdateInternalDocumentsEventOperationOneOf {
+    /** insert/update documents */
+    update?: InternalDocumentUpdateOperation;
+    /** delete by document ids */
+    deleteByIds?: DeleteByIdsOperation;
+    /** delete documents matching filter */
+    deleteByFilter?: DeleteByFilterOperation;
+    /** update internal documents matching filter */
+    updateByFilter?: InternalDocumentUpdateByFilterOperation;
+    /** update only existing documents */
+    updateExisting?: InternalUpdateExistingOperation;
+    /** insert/update documents with versioning */
+    versionedUpdate?: VersionedDocumentUpdateOperation;
+    /** delete by document ids with versioning */
+    versionedDeleteByIds?: VersionedDeleteByIdsOperation;
+    /** type of the documents */
+    documentType?: string;
+    /** language of the documents (mandatory) */
+    language?: string | null;
+    /**
+     * one or more search documents
+     * @deprecated
+     */
+    addDocuments?: InternalDocument[];
+    /**
+     * one or more ids of indexed documents to be removed. Removal will happen before addition (if both provided)
+     * @deprecated
+     */
+    removeDocumentIds?: string[];
+    /** id to pass to processing notification */
+    correlationId?: string | null;
+}
+/** @oneof */
+interface UpdateInternalDocumentsEventOperationOneOf {
+    /** insert/update documents */
+    update?: InternalDocumentUpdateOperation;
+    /** delete by document ids */
+    deleteByIds?: DeleteByIdsOperation;
+    /** delete documents matching filter */
+    deleteByFilter?: DeleteByFilterOperation;
+    /** update internal documents matching filter */
+    updateByFilter?: InternalDocumentUpdateByFilterOperation;
+    /** update only existing documents */
+    updateExisting?: InternalUpdateExistingOperation;
+    /** insert/update documents with versioning */
+    versionedUpdate?: VersionedDocumentUpdateOperation;
+    /** delete by document ids with versioning */
+    versionedDeleteByIds?: VersionedDeleteByIdsOperation;
+}
+interface InternalDocument {
+    /** document with mandatory fields (id) and with fields specific to the type of the document */
+    document?: Record<string, any> | null;
+}
+interface InternalDocumentUpdateOperation {
+    /** documents to index or update */
+    documents?: InternalDocument[];
+}
+interface DeleteByIdsOperation {
+    /** ids of the documents to delete */
+    documentIds?: string[];
+}
+interface DeleteByFilterOperation {
+    /** documents matching this filter wil be deleted. only filterable documents defined in document_type can be used for filtering */
+    filter?: Record<string, any> | null;
+}
+interface InternalDocumentUpdateByFilterOperation {
+    /** documents matching this filter will be updated */
+    filter?: Record<string, any> | null;
+    /** partial document to apply */
+    document?: InternalDocument;
+}
+interface InternalUpdateExistingOperation {
+    /** documents to update */
+    documents?: InternalDocument[];
+}
+interface VersionedDocumentUpdateOperation {
+    /** documents to create or overwrite */
+    documents?: InternalDocument[];
+    /** versioning mode to use instead of default */
+    versioningMode?: VersioningMode;
+}
+declare enum VersioningMode {
+    /** use default versioning mode agreed with search team */
+    DEFAULT = "DEFAULT",
+    /** execute only if version is greater than existing */
+    GREATER_THAN = "GREATER_THAN",
+    /** execute only if version is greater or equal to existing */
+    GREATER_OR_EQUAL = "GREATER_OR_EQUAL"
+}
+interface VersionedDeleteByIdsOperation {
+    /** ids with version of the documents to delete */
+    documentIds?: VersionedDocumentId[];
+}
+interface VersionedDocumentId {
+    /** document id */
+    documentId?: string;
+    /** document version */
+    version?: string;
+    /** versioning mode to use instead of default */
+    versioningMode?: VersioningMode;
+}
+interface UpdateDocumentsEvent extends UpdateDocumentsEventOperationOneOf {
+    /** insert/update documents */
+    update?: DocumentUpdateOperation;
+    /** delete by document ids */
+    deleteByIds?: V1DeleteByIdsOperation;
+    /** delete documents matching filter */
+    deleteByFilter?: V1DeleteByFilterOperation;
+    /** update documents matching filter */
+    updateByFilter?: UpdateByFilterOperation;
+    /** update only existing documents */
+    updateExisting?: UpdateExistingOperation;
+    /** application which owns documents */
+    appDefId?: string | null;
+    /** type of the documents */
+    documentType?: string | null;
+    /** language of the documents */
+    language?: string | null;
+    /** site documents belong to */
+    msId?: string | null;
+}
+/** @oneof */
+interface UpdateDocumentsEventOperationOneOf {
+    /** insert/update documents */
+    update?: DocumentUpdateOperation;
+    /** delete by document ids */
+    deleteByIds?: V1DeleteByIdsOperation;
+    /** delete documents matching filter */
+    deleteByFilter?: V1DeleteByFilterOperation;
+    /** update documents matching filter */
+    updateByFilter?: UpdateByFilterOperation;
+    /** update only existing documents */
+    updateExisting?: UpdateExistingOperation;
+}
+interface DocumentUpdateOperation {
+    /** documents to index or update */
+    documents?: IndexDocument[];
+}
+interface IndexDocument {
+    /** data bag with non-searchable fields (url, image) */
+    payload?: DocumentPayload;
+    /** what type of users should documents be visible to */
+    exposure?: Enum;
+    /** document with mandatory fields (id, title, description) and with fields specific to the type of the document */
+    document?: Record<string, any> | null;
+    /** what member groups is the document exposed to. Used only with GROUP_PROTECTED exposure */
+    permittedMemberGroups?: string[];
+    /** if true SEO is disabled for this document */
+    seoHidden?: boolean | null;
+    /** if true the page is a lightbox popup */
+    isPopup?: boolean | null;
+}
+interface DocumentPayload {
+    /** url of the page representing the document */
+    url?: string | null;
+    /** image which represents the document */
+    documentImage?: DocumentImage;
+}
+interface DocumentImage {
+    /** the name of the image */
+    name?: string;
+    /** the width of the image */
+    width?: number;
+    /** the height of the image */
+    height?: number;
+}
+declare enum Enum {
+    /** Default value. Means that permission not set */
+    UNKNOWN = "UNKNOWN",
+    /** Protected exposure. Exposed to members and owners */
+    PROTECTED = "PROTECTED",
+    /** Private exposure. Exposed to owners */
+    PRIVATE = "PRIVATE",
+    /** Public exposure. Visible to everyone */
+    PUBLIC = "PUBLIC",
+    /** Used for partial updates, to state that exposure is not changing */
+    UNCHANGED = "UNCHANGED",
+    /** Protected to members of permitted groups and owners */
+    GROUP_PROTECTED = "GROUP_PROTECTED"
+}
+interface V1DeleteByIdsOperation {
+    /** ids of the documents to delete */
+    documentIds?: string[];
+}
+interface V1DeleteByFilterOperation {
+    /** documents matching this filter wil be deleted. only filterable documents defined in document_type can be used for filtering */
+    filter?: Record<string, any> | null;
+}
+interface UpdateByFilterOperation {
+    /** documents matching this filter will be updated */
+    filter?: Record<string, any> | null;
+    /** partial document to apply */
+    document?: IndexDocument;
+}
+interface UpdateExistingOperation {
+    /** documents to update */
+    documents?: IndexDocument[];
+}
+interface Empty {
+}
+interface MessageEnvelope {
+    /** App instance ID. */
+    instanceId?: string | null;
+    /** Event type. */
+    eventType?: string;
+    /** The identification type and identity data. */
+    identity?: IdentificationData;
+    /** Stringify payload. */
+    data?: string;
+}
+interface IdentificationData extends IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+    /** @readonly */
+    identityType?: WebhookIdentityType;
+}
+/** @oneof */
+interface IdentificationDataIdOneOf {
+    /** ID of a site visitor that has not logged in to the site. */
+    anonymousVisitorId?: string;
+    /** ID of a site visitor that has logged in to the site. */
+    memberId?: string;
+    /** ID of a Wix user (site owner, contributor, etc.). */
+    wixUserId?: string;
+    /** ID of an app. */
+    appId?: string;
+}
+declare enum WebhookIdentityType {
+    UNKNOWN = "UNKNOWN",
+    ANONYMOUS_VISITOR = "ANONYMOUS_VISITOR",
+    MEMBER = "MEMBER",
+    WIX_USER = "WIX_USER",
+    APP = "APP"
+}
+interface SearchRequest {
+    /** 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 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 FederatedSearchRequest {
+    /** 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 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 SuggestRequest {
+    /** 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 SuggestResponse {
+    /** Suggested documents. */
+    documents?: Record<string, any>[] | null;
+}
+interface FederatedSuggestRequest {
+    /** 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 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 RelatedRequest {
+    /** 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 RelatedResponse {
+    /** Documents matching filter and query. */
+    documents?: Record<string, any>[] | null;
+}
+interface AutocompleteRequest {
+    /** 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 AutocompleteResponse {
+    /** Suggested phrases. */
+    values?: AutocompleteResponseValue[];
+}
+interface AutocompleteResponseValue {
+    /** Suggested phrase. */
+    query?: string;
+}
+interface FederatedAutocompleteRequest {
+    /** 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 FederatedAutocompleteResponse {
+    /** Suggested phrases from multiple indexes */
+    results?: FederatedAutocompleteResults[];
+}
+interface FederatedAutocompleteResults {
+    /** Document type of queries */
+    documentType?: string | null;
+    /** Suggested phrases */
+    values?: AutocompleteResponseValue[];
+}
+interface TrendingRequest {
+    documentTypes?: string[];
+    language?: string | null;
+    /** Include seo hidden documents. Defaults to false if not provided. */
+    includeSeoHidden?: boolean | null;
+}
+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 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;
+}
+
+declare const __metadata: {
+    PACKAGE_NAME: string;
+};
+declare function search(httpClient: HttpClient): (options?: SearchOptions) => Promise<SearchResponse & SearchResponseNonNullableFields>;
+
+type index_d_Aggregation = Aggregation;
+declare const index_d_Aggregation: typeof Aggregation;
+type index_d_AggregationFacet = AggregationFacet;
+type index_d_AutocompleteRequest = AutocompleteRequest;
+type index_d_AutocompleteResponse = AutocompleteResponse;
+type index_d_AutocompleteResponseValue = AutocompleteResponseValue;
+type index_d_DeleteByFilterOperation = DeleteByFilterOperation;
+type index_d_DeleteByIdsOperation = DeleteByIdsOperation;
+type index_d_Direction = Direction;
+declare const index_d_Direction: typeof Direction;
+type index_d_DocumentImage = DocumentImage;
+type index_d_DocumentPayload = DocumentPayload;
+type index_d_DocumentUpdateOperation = DocumentUpdateOperation;
+type index_d_Empty = Empty;
+type index_d_Enum = Enum;
+declare const index_d_Enum: typeof Enum;
+type index_d_FacetClause = FacetClause;
+type index_d_FacetClauseClauseOneOf = FacetClauseClauseOneOf;
+type index_d_FacetClauses = FacetClauses;
+type index_d_FacetCountResponse = FacetCountResponse;
+type index_d_FacetsResponse = FacetsResponse;
+type index_d_FacetsResponseResponseOneOf = FacetsResponseResponseOneOf;
+type index_d_FederatedAutocompleteRequest = FederatedAutocompleteRequest;
+type index_d_FederatedAutocompleteResponse = FederatedAutocompleteResponse;
+type index_d_FederatedAutocompleteResults = FederatedAutocompleteResults;
+type index_d_FederatedSearchDocuments = FederatedSearchDocuments;
+type index_d_FederatedSearchRequest = FederatedSearchRequest;
+type index_d_FederatedSearchResponse = FederatedSearchResponse;
+type index_d_FederatedSuggestDocuments = FederatedSuggestDocuments;
+type index_d_FederatedSuggestRequest = FederatedSuggestRequest;
+type index_d_FederatedSuggestResponse = FederatedSuggestResponse;
+type index_d_HierarchicalAggregationResponse = HierarchicalAggregationResponse;
+type index_d_HierarchicalFacet = HierarchicalFacet;
+type index_d_HierarchicalFacetClauseOneOf = HierarchicalFacetClauseOneOf;
+type index_d_IdentificationData = IdentificationData;
+type index_d_IdentificationDataIdOneOf = IdentificationDataIdOneOf;
+type index_d_IndexDocument = IndexDocument;
+type index_d_InternalDocument = InternalDocument;
+type index_d_InternalDocumentUpdateByFilterOperation = InternalDocumentUpdateByFilterOperation;
+type index_d_InternalDocumentUpdateOperation = InternalDocumentUpdateOperation;
+type index_d_InternalUpdateExistingOperation = InternalUpdateExistingOperation;
+type index_d_MaxAggregationResponse = MaxAggregationResponse;
+type index_d_MessageEnvelope = MessageEnvelope;
+type index_d_MinAggregationResponse = MinAggregationResponse;
+type index_d_MinMaxAggregationResponse = MinMaxAggregationResponse;
+type index_d_NextPageResponse = NextPageResponse;
+type index_d_OrderingClause = OrderingClause;
+type index_d_OrderingClauses = OrderingClauses;
+type index_d_RelatedRequest = RelatedRequest;
+type index_d_RelatedResponse = RelatedResponse;
+type index_d_SearchOptions = SearchOptions;
+type index_d_SearchPaging = SearchPaging;
+type index_d_SearchProperty = SearchProperty;
+type index_d_SearchRequest = SearchRequest;
+type index_d_SearchResponse = SearchResponse;
+type index_d_SearchResponseNonNullableFields = SearchResponseNonNullableFields;
+type index_d_SiteDocument = SiteDocument;
+type index_d_SuggestRequest = SuggestRequest;
+type index_d_SuggestResponse = SuggestResponse;
+type index_d_SumAggregationResponse = SumAggregationResponse;
+type index_d_TermAggregationResponse = TermAggregationResponse;
+type index_d_TermFacet = TermFacet;
+type index_d_TrendingItems = TrendingItems;
+type index_d_TrendingRequest = TrendingRequest;
+type index_d_TrendingResponse = TrendingResponse;
+type index_d_UpdateByFilterOperation = UpdateByFilterOperation;
+type index_d_UpdateDocumentsEvent = UpdateDocumentsEvent;
+type index_d_UpdateDocumentsEventOperationOneOf = UpdateDocumentsEventOperationOneOf;
+type index_d_UpdateExistingOperation = UpdateExistingOperation;
+type index_d_UpdateInternalDocumentsEvent = UpdateInternalDocumentsEvent;
+type index_d_UpdateInternalDocumentsEventOperationOneOf = UpdateInternalDocumentsEventOperationOneOf;
+type index_d_V1DeleteByFilterOperation = V1DeleteByFilterOperation;
+type index_d_V1DeleteByIdsOperation = V1DeleteByIdsOperation;
+type index_d_Value = Value;
+type index_d_VersionedDeleteByIdsOperation = VersionedDeleteByIdsOperation;
+type index_d_VersionedDocumentId = VersionedDocumentId;
+type index_d_VersionedDocumentUpdateOperation = VersionedDocumentUpdateOperation;
+type index_d_VersioningMode = VersioningMode;
+declare const index_d_VersioningMode: typeof VersioningMode;
+type index_d_WebhookIdentityType = WebhookIdentityType;
+declare const index_d_WebhookIdentityType: typeof WebhookIdentityType;
+declare const index_d___metadata: typeof __metadata;
+declare const index_d_search: typeof search;
+declare namespace index_d {
+  export { index_d_Aggregation as Aggregation, type index_d_AggregationFacet as AggregationFacet, type index_d_AutocompleteRequest as AutocompleteRequest, type index_d_AutocompleteResponse as AutocompleteResponse, type index_d_AutocompleteResponseValue as AutocompleteResponseValue, type index_d_DeleteByFilterOperation as DeleteByFilterOperation, type index_d_DeleteByIdsOperation as DeleteByIdsOperation, index_d_Direction as Direction, type index_d_DocumentImage as DocumentImage, type index_d_DocumentPayload as DocumentPayload, type index_d_DocumentUpdateOperation as DocumentUpdateOperation, type index_d_Empty as Empty, index_d_Enum as Enum, type index_d_FacetClause as FacetClause, type index_d_FacetClauseClauseOneOf as FacetClauseClauseOneOf, type index_d_FacetClauses as FacetClauses, type index_d_FacetCountResponse as FacetCountResponse, type index_d_FacetsResponse as FacetsResponse, type index_d_FacetsResponseResponseOneOf as FacetsResponseResponseOneOf, type index_d_FederatedAutocompleteRequest as FederatedAutocompleteRequest, type index_d_FederatedAutocompleteResponse as FederatedAutocompleteResponse, type index_d_FederatedAutocompleteResults as FederatedAutocompleteResults, type index_d_FederatedSearchDocuments as FederatedSearchDocuments, type index_d_FederatedSearchRequest as FederatedSearchRequest, type index_d_FederatedSearchResponse as FederatedSearchResponse, type index_d_FederatedSuggestDocuments as FederatedSuggestDocuments, type index_d_FederatedSuggestRequest as FederatedSuggestRequest, type index_d_FederatedSuggestResponse as FederatedSuggestResponse, type index_d_HierarchicalAggregationResponse as HierarchicalAggregationResponse, type index_d_HierarchicalFacet as HierarchicalFacet, type index_d_HierarchicalFacetClauseOneOf as HierarchicalFacetClauseOneOf, type index_d_IdentificationData as IdentificationData, type index_d_IdentificationDataIdOneOf as IdentificationDataIdOneOf, type index_d_IndexDocument as IndexDocument, type index_d_InternalDocument as InternalDocument, type index_d_InternalDocumentUpdateByFilterOperation as InternalDocumentUpdateByFilterOperation, type index_d_InternalDocumentUpdateOperation as InternalDocumentUpdateOperation, type index_d_InternalUpdateExistingOperation as InternalUpdateExistingOperation, type index_d_MaxAggregationResponse as MaxAggregationResponse, type index_d_MessageEnvelope as MessageEnvelope, type index_d_MinAggregationResponse as MinAggregationResponse, type index_d_MinMaxAggregationResponse as MinMaxAggregationResponse, type index_d_NextPageResponse as NextPageResponse, type index_d_OrderingClause as OrderingClause, type index_d_OrderingClauses as OrderingClauses, type index_d_RelatedRequest as RelatedRequest, type index_d_RelatedResponse as RelatedResponse, type index_d_SearchOptions as SearchOptions, type index_d_SearchPaging as SearchPaging, type index_d_SearchProperty as SearchProperty, type index_d_SearchRequest as SearchRequest, type index_d_SearchResponse as SearchResponse, type index_d_SearchResponseNonNullableFields as SearchResponseNonNullableFields, type index_d_SiteDocument as SiteDocument, type index_d_SuggestRequest as SuggestRequest, type index_d_SuggestResponse as SuggestResponse, type index_d_SumAggregationResponse as SumAggregationResponse, type index_d_TermAggregationResponse as TermAggregationResponse, type index_d_TermFacet as TermFacet, type index_d_TrendingItems as TrendingItems, type index_d_TrendingRequest as TrendingRequest, type index_d_TrendingResponse as TrendingResponse, type index_d_UpdateByFilterOperation as UpdateByFilterOperation, type index_d_UpdateDocumentsEvent as UpdateDocumentsEvent, type index_d_UpdateDocumentsEventOperationOneOf as UpdateDocumentsEventOperationOneOf, type index_d_UpdateExistingOperation as UpdateExistingOperation, type index_d_UpdateInternalDocumentsEvent as UpdateInternalDocumentsEvent, type index_d_UpdateInternalDocumentsEventOperationOneOf as UpdateInternalDocumentsEventOperationOneOf, type index_d_V1DeleteByFilterOperation as V1DeleteByFilterOperation, type index_d_V1DeleteByIdsOperation as V1DeleteByIdsOperation, type index_d_Value as Value, type index_d_VersionedDeleteByIdsOperation as VersionedDeleteByIdsOperation, type index_d_VersionedDocumentId as VersionedDocumentId, type index_d_VersionedDocumentUpdateOperation as VersionedDocumentUpdateOperation, index_d_VersioningMode as VersioningMode, index_d_WebhookIdentityType as WebhookIdentityType, index_d___metadata as __metadata, index_d_search as search };
+}
+
+export { index_d as siteSearch, index_d$1 as wixSiteSearch };