@usereactify/search 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/src/hooks/usePagination.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePagination = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+const usePagination = (input) => {
+    const { track } = (0, hooks_1.useAnalytics)();
+    const buildPagePath = react_1.default.useCallback((page) => {
+        const currentPath = window.location.pathname;
+        return currentPath.includes("page=")
+            ? currentPath.replace(/page=\d+/g, `page=${page}`)
+            : `${currentPath}${currentPath.includes("?") ? "&" : "?"}page=${page}`;
+    }, []);
+    const pagesToShow = react_1.default.useMemo(() => getPages(input.pages, input.totalPages, input.currentPage), [input.pages, input.totalPages, input.currentPage]);
+    // default input.currentPage is zero-indexed, actualCurrentPage is one-indexed
+    const actualCurrentPage = react_1.default.useMemo(() => input.currentPage + 1, [input.currentPage]);
+    const hasNextPage = react_1.default.useMemo(() => actualCurrentPage < input.totalPages, [actualCurrentPage, input.totalPages]);
+    const hasPreviousPage = react_1.default.useMemo(() => actualCurrentPage > 1, [actualCurrentPage]);
+    const hasPage = react_1.default.useCallback((pageNumber) => {
+        return pageNumber >= 0 && pageNumber < input.totalPages;
+    }, [input.totalPages]);
+    const handlePageChange = react_1.default.useCallback((pageNumber, event) => {
+        event === null || event === void 0 ? void 0 : event.preventDefault();
+        if (!hasPage(pageNumber)) {
+            return;
+        }
+        input.setPage(pageNumber);
+        track({
+            eventName: "paginationChange",
+            payload: {
+                page: pageNumber,
+                source: window.location.pathname.includes("/search")
+                    ? "search"
+                    : "collection",
+            },
+        });
+    }, [input.setPage, track]);
+    const handleNextPage = react_1.default.useCallback((event) => {
+        handlePageChange(input.currentPage + 1, event);
+    }, [hasNextPage, input.currentPage, handlePageChange]);
+    const handlePreviousPage = react_1.default.useCallback((event) => {
+        handlePageChange(input.currentPage - 1, event);
+    }, [hasPreviousPage, input.currentPage, handlePageChange]);
+    return react_1.default.useMemo(() => ({
+        currentPage: input.currentPage,
+        totalPages: input.totalPages,
+        pagesToShow,
+        hasNextPage,
+        buildPagePath,
+        hasPreviousPage,
+        actualCurrentPage,
+        handleNextPage,
+        handlePreviousPage,
+        handlePageChange,
+    }), [
+        input.currentPage,
+        input.totalPages,
+        pagesToShow,
+        hasNextPage,
+        buildPagePath,
+        hasPreviousPage,
+        actualCurrentPage,
+        handleNextPage,
+        handlePreviousPage,
+        handlePageChange,
+    ]);
+};
+exports.usePagination = usePagination;
+// get a list of pages to display buttons for
+// @todo this is super hacky and needs to be cleaned up
+const getPages = (pages, totalPages, currentPage) => {
+    const pagesToShow = pages > totalPages ? totalPages : pages;
+    const buffer = Math.floor(pagesToShow / 2);
+    let list = [];
+    let start = 0;
+    if (totalPages <= 5 || currentPage < buffer + 1) {
+        start = 0;
+    }
+    else {
+        if (totalPages - buffer <= currentPage) {
+            start =
+                currentPage + 1 === totalPages
+                    ? currentPage - (pagesToShow - 1)
+                    : currentPage - (buffer + buffer / 2);
+        }
+        else {
+            start = currentPage - buffer;
+        }
+    }
+    Array.apply(null, Array(pagesToShow)).map((item, index) => {
+        list.push(start + index);
+    });
+    return list;
+};

package/dist/src/hooks/usePaginationLoadMore.d.ts

@@ -0,0 +1,15 @@
+import { ReactivesearchResultProps } from "../types/reactivesearch";
+export declare const usePaginationLoadMore: (input: ReactivesearchResultProps) => {
+    loading: boolean;
+    hasMore: boolean;
+    handleLoadMore: () => void;
+    resultStats: {
+        time: number;
+        hidden: number;
+        promoted: number;
+        currentPage: number;
+        numberOfPages: number;
+        numberOfResults?: number;
+        displayedResults: number;
+    };
+};

package/dist/src/hooks/usePaginationLoadMore.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePaginationLoadMore = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+const usePaginationLoadMore = (input) => {
+    const analyticsHook = (0, hooks_1.useAnalytics)();
+    const filterStack = (0, hooks_1.useFilterStack)();
+    const hasMore = input.resultStats.displayedResults !== input.resultStats.numberOfResults;
+    const handleLoadMore = react_1.default.useCallback(() => {
+        input.loadMore();
+        analyticsHook.track({
+            eventName: "paginationChange",
+            payload: {
+                page: Math.ceil(input.resultStats.displayedResults / ((filterStack === null || filterStack === void 0 ? void 0 : filterStack.pageSize) || 20)) + 1,
+                source: window.location.pathname.includes("/search")
+                    ? "search"
+                    : "collection",
+            },
+        });
+    }, [input.loadMore, analyticsHook.track, input.resultStats, filterStack]);
+    return react_1.default.useMemo(() => ({
+        loading: input.loading,
+        hasMore,
+        handleLoadMore,
+        resultStats: input.resultStats,
+    }), [
+        input.loading,
+        hasMore,
+        handleLoadMore,
+        input.resultStats,
+    ]);
+};
+exports.usePaginationLoadMore = usePaginationLoadMore;

package/dist/src/hooks/useProductPrice.d.ts

@@ -0,0 +1,10 @@
+import currency from "currency.js";
+import { ElasticProduct } from "../types/elastic";
+export declare const useProductPrice: (product: ElasticProduct) => {
+    price?: currency;
+    onSale: boolean;
+    currencyCode: string;
+    compareAtPrice?: currency;
+    formattedPrice?: string;
+    formattedCompareAtPrice?: string;
+};

package/dist/src/hooks/useProductPrice.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProductPrice = void 0;
+const react_1 = __importDefault(require("react"));
+const currency_js_1 = __importDefault(require("currency.js"));
+const useProductPrice = (product) => {
+    return react_1.default.useMemo(() => {
+        var _a, _b, _c, _d;
+        const variant = (_a = product.variants) === null || _a === void 0 ? void 0 : _a[0];
+        if (!variant) {
+            return {
+                onSale: false,
+                price: undefined,
+                currencyCode: "AUD",
+                compareAtPrice: undefined,
+            };
+        }
+        // @todo select the appropriate currency
+        const priceSet = (_b = variant.presentment_prices) === null || _b === void 0 ? void 0 : _b[0];
+        if (!priceSet || !priceSet.price) {
+            return {
+                onSale: false,
+                price: undefined,
+                currencyCode: "AUD",
+                compareAtPrice: undefined,
+            };
+        }
+        const currencyCode = (_c = priceSet.price.currency_code) !== null && _c !== void 0 ? _c : "AUD";
+        const price = priceSet.price.amount
+            ? (0, currency_js_1.default)(priceSet.price.amount)
+            : undefined;
+        const formattedPrice = price ? formatPrice(price, currencyCode) : undefined;
+        const compareAtPrice = ((_d = priceSet.compare_at_price) === null || _d === void 0 ? void 0 : _d.amount)
+            ? (0, currency_js_1.default)(priceSet.compare_at_price.amount)
+            : undefined;
+        const formattedCompareAtPrice = compareAtPrice
+            ? formatPrice(compareAtPrice, currencyCode)
+            : undefined;
+        const onSale = !!compareAtPrice && !!price && compareAtPrice.intValue > price.intValue;
+        return {
+            price,
+            onSale,
+            currencyCode,
+            compareAtPrice,
+            formattedPrice,
+            formattedCompareAtPrice,
+        };
+    }, [product]);
+};
+exports.useProductPrice = useProductPrice;
+const formatPrice = (price, currencyCode) => {
+    let priceString = new Intl.NumberFormat("en-AU", {
+        style: "currency",
+        currency: currencyCode,
+    }).format(price.value);
+    if ("AUD" === currencyCode) {
+        priceString = `AU ${priceString}`;
+    }
+    return priceString;
+};

package/dist/src/hooks/useReactifySearchContext.d.ts

@@ -0,0 +1,78 @@
+import React from "react";
+import { Config } from "../types";
+export declare const ReactifySearchContext: React.Context<{
+    config: Config;
+    options: {
+        mode: "search" | "collection" | "instant-search";
+        index: string;
+        shopifyPermanentDomain: string;
+        filterStackHandle?: string | undefined;
+        credentials: {
+            username: string;
+            password: string;
+            endpoint: string;
+        };
+        onRedirect?: ((type: "redirect" | "search", url: string) => void) | undefined;
+        theme: Record<string, unknown>;
+        additionalComponentHandles?: string[] | undefined;
+    } & ({
+        mode: "search";
+    } | {
+        mode: "collection";
+        collection: {
+            id: number;
+            handle: string;
+            title: string;
+        };
+    } | {
+        mode: "instant-search";
+    });
+    search: {
+        searchQuery: string;
+        setSearchQuery: React.Dispatch<React.SetStateAction<string>>;
+        instantSearchVisible: boolean;
+        setInstantSearchVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    };
+    sortby: {
+        sortOption: string;
+        setSortOption: React.Dispatch<React.SetStateAction<string>>;
+    };
+} | undefined>;
+export declare const useReactifySearchContext: () => {
+    config: Config;
+    options: {
+        mode: "search" | "collection" | "instant-search";
+        index: string;
+        shopifyPermanentDomain: string;
+        filterStackHandle?: string | undefined;
+        credentials: {
+            username: string;
+            password: string;
+            endpoint: string;
+        };
+        onRedirect?: ((type: "redirect" | "search", url: string) => void) | undefined;
+        theme: Record<string, unknown>;
+        additionalComponentHandles?: string[] | undefined;
+    } & ({
+        mode: "search";
+    } | {
+        mode: "collection";
+        collection: {
+            id: number;
+            handle: string;
+            title: string;
+        };
+    } | {
+        mode: "instant-search";
+    });
+    search: {
+        searchQuery: string;
+        setSearchQuery: React.Dispatch<React.SetStateAction<string>>;
+        instantSearchVisible: boolean;
+        setInstantSearchVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    };
+    sortby: {
+        sortOption: string;
+        setSortOption: React.Dispatch<React.SetStateAction<string>>;
+    };
+};

package/dist/src/hooks/useReactifySearchContext.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactifySearchContext = exports.ReactifySearchContext = void 0;
+const react_1 = __importDefault(require("react"));
+exports.ReactifySearchContext = react_1.default.createContext(undefined);
+const useReactifySearchContext = () => react_1.default.useContext(exports.ReactifySearchContext);
+exports.useReactifySearchContext = useReactifySearchContext;

package/dist/src/hooks/useSearch.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export declare const useSearch: () => {
+    searchQuery: string;
+    setSearchQuery: React.Dispatch<React.SetStateAction<string>>;
+    submitSearch: (localSearchQuery?: string | undefined) => void;
+    showInstantSearchResults: boolean;
+    setShowInstantSearchResults: React.Dispatch<React.SetStateAction<boolean>>;
+};

package/dist/src/hooks/useSearch.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSearch = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+const useSearch = () => {
+    const { options, config, search } = (0, hooks_1.useReactifySearchContext)();
+    const handleSubmitSearch = react_1.default.useCallback((localSearchQuery) => {
+        const actualSearchQuery = localSearchQuery !== null && localSearchQuery !== void 0 ? localSearchQuery : search.searchQuery;
+        if (!actualSearchQuery)
+            return;
+        const redirect = config.redirects.find((redirect) => redirect.query.trim().toLowerCase() ===
+            actualSearchQuery.trim().toLowerCase());
+        search.setInstantSearchVisible(false);
+        if (options.onRedirect) {
+            options.onRedirect(redirect ? "redirect" : "search", redirect ? redirect.url : `/search?q=${actualSearchQuery}`);
+        }
+        else if (redirect) {
+            window.location.href = redirect.url;
+        }
+        else {
+            window.location.href = `/search?q=${actualSearchQuery}`;
+        }
+    }, [search.searchQuery]);
+    return {
+        searchQuery: search.searchQuery,
+        setSearchQuery: search.setSearchQuery,
+        submitSearch: handleSubmitSearch,
+        showInstantSearchResults: !!search.instantSearchVisible && !!search.searchQuery,
+        setShowInstantSearchResults: search.setInstantSearchVisible,
+    };
+};
+exports.useSearch = useSearch;

package/dist/src/hooks/useSortby.d.ts

@@ -0,0 +1,6 @@
+import { ConfigSort } from "../types";
+export declare const useSortby: () => {
+    sortOption: ConfigSort | undefined;
+    sortOptions: Array<ConfigSort>;
+    setSortOption: (sortOptionHandle: string, ignoreHistoryState?: boolean | undefined) => void;
+};

package/dist/src/hooks/useSortby.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSortby = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+const useSortby = () => {
+    const { options, config, sortby } = (0, hooks_1.useReactifySearchContext)();
+    const { track } = (0, hooks_1.useAnalytics)();
+    const sortOptions = react_1.default.useMemo(() => {
+        return config.sort
+            .sort((a, b) => `${a.position}`.localeCompare(`${b.position}`))
+            .filter(({ visibility }) => ["all", options.mode].includes(visibility));
+    }, [options.mode, config]);
+    const sortOption = react_1.default.useMemo(() => sortOptions.find(({ handle }) => handle === sortby.sortOption) ||
+        sortOptions[0], [sortOptions, sortby.sortOption]);
+    const setSortOption = react_1.default.useCallback((sortOptionHandle, ignoreHistoryState = false) => {
+        sortby.setSortOption(sortOptionHandle);
+        if (!ignoreHistoryState) {
+            const url = new URL(window.location.href);
+            url.searchParams.has("sort")
+                ? url.searchParams.set("sort", sortOptionHandle)
+                : url.searchParams.append("sort", sortOptionHandle);
+            window.history.pushState({}, "", url.toString());
+        }
+        track({
+            eventName: "sortChange",
+            payload: {
+                type: sortOptionHandle,
+            },
+        });
+    }, [window.location.href]);
+    return {
+        sortOptions,
+        sortOption,
+        setSortOption,
+    };
+};
+exports.useSortby = useSortby;

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./components";
+export * from "./hooks";
+export * from "./types";

package/dist/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./components"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./types"), exports);
+const package_json_1 = require("../package.json");
+const debug = require("debug")("reactify-search:");
+debug(`${package_json_1.name} v${package_json_1.version}`);

package/dist/src/types/config.d.ts

@@ -0,0 +1,26 @@
+import { Sort, Filter, FilterOption, Redirect, Field, Curation } from "./firestore";
+export interface Config {
+    index: string;
+    sort: ConfigSort[];
+    fields: ConfigField[];
+    filters: ConfigFilter[];
+    redirects: ConfigRedirect[];
+    curations: ConfigCuration[];
+}
+export declare type ConfigSort = Omit<Sort, "enabled">;
+export declare type ConfigField = Omit<Field, "enabled">;
+export declare type ConfigRedirect = Omit<Redirect, "enabled" | "keywords">;
+export declare type ConfigFilter = Omit<Filter, "enabled" | "keywords"> & {
+    options: Omit<FilterOption, "enabled">[];
+};
+export declare type ConfigFilterOption = Omit<FilterOption, "enabled">;
+export declare type ConfigCuration = Omit<Curation, "keywords" | "boosting" | "longRunningTask" | "callouts"> & {
+    boosting: {
+        groupings: (NonNullable<NonNullable<Curation["boosting"]>["groupings"]>[0] & {
+            query: string;
+        })[];
+        sortings: (NonNullable<NonNullable<Curation["boosting"]>["sortings"]>[0] & {
+            query: string;
+        })[];
+    };
+};

package/dist/src/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/elastic.d.ts

@@ -0,0 +1,209 @@
+import { Callout } from "./firestore";
+import { Maybe, ProductVariantInventoryPolicy, MetafieldValueType } from "./graphql";
+export declare enum ElasticDocumentType {
+    Callout = "callout",
+    Product = "product"
+}
+export declare type ElasticDocument = ElasticCallout | ElasticProduct;
+export interface ElasticCallout {
+    type: ElasticDocumentType.Callout;
+    key: string;
+    callout: Omit<Callout, "keywords">;
+    /** elastic callouts are always published */
+    published: true;
+    /** elastic callouts are always attached to one curation */
+    curations: [ElasticCuration];
+}
+export interface ElasticProduct {
+    type: ElasticDocumentType.Product;
+    /** the log id from which this product was last uploaded */
+    lastLogId: string;
+    /** legacy resource id */
+    id: number;
+    storefrontId: string;
+    title: string;
+    description: string;
+    vendor: string;
+    product_type: string;
+    handle: string;
+    url: string;
+    tags: string[];
+    collection_titles: string[];
+    /** tag prefixes defined in tagKeys are split to their own attributes */
+    [key: `tags_${string}`]: string[] | undefined;
+    /** decimal number e.g. 99.95 */
+    price_min: number;
+    /** decimal number e.g. 99.95 */
+    price_max: number;
+    /** array of option names e.g. ["Colour", "Size"] */
+    options: string[];
+    /** @todo it would be better to use ProductStatus directly, which has uppercase */
+    status: "active" | "archived" | "draft";
+    published: boolean;
+    /** ISO 8601 datetime */
+    published_at: Maybe<string>;
+    /** ISO 8601 datetime */
+    updated_at: string;
+    /** ISO 8601 datetime */
+    created_at: string;
+    tracks_inventory: boolean;
+    /** originalSrc URL for featured image */
+    image: Maybe<string>;
+    /** array of images (undefined if images are disabled in sync settings) */
+    images?: ElasticImage[];
+    /** array of variants attached to product (undefined if variants are disabled in sync settings) */
+    variants?: ElasticVariant[];
+    /** price ranges from presentment prices (undefined if presentment prices or variants are disabled in sync settings) */
+    presentment_price_ranges?: {
+        min_variant_price: ElasticPresentmentPrice[];
+        max_variant_price: ElasticPresentmentPrice[];
+    };
+    /** array of variant skus (undefined if variants are disabled in sync settings) */
+    variant_skus?: string[];
+    /** combined array of option values from all option types (undefined if variants are disabled in sync settings) */
+    variant_options?: string[];
+    /** array of collections which this product belongs to (undefined if collections are disabled in sync settings) */
+    collections?: ElasticCollection[];
+    /** array of whitelisted metafields (undefined if metafields are disabled in sync settings) */
+    metafields?: ElasticMetafield[];
+    /** decimal number e.g. 99.95 (undefined if variants are disabled in sync settings) */
+    discount_amount?: number;
+    /** combined inventory for all variants (undefined if variants are disabled in sync settings) */
+    inventory_total?: number;
+    /** number of days since published, null if unpublished */
+    published_days: Maybe<number>;
+    /** collection of curations that this product is attached to */
+    curations?: ElasticCuration[];
+}
+export interface ElasticVariant {
+    /** legacy resource id */
+    id: number;
+    storefrontId: string;
+    title: string;
+    sku: Maybe<string>;
+    barcode: Maybe<string>;
+    /** array of presentment prices (undefined if presentment prices are disabled in sync settings) */
+    presentment_prices?: {
+        price: ElasticPresentmentPrice;
+        compare_at_price: Maybe<ElasticPresentmentPrice>;
+    }[];
+    /** decimal number e.g. 99.95 */
+    price: number;
+    /** decimal number e.g. 99.95 */
+    compare_at_price: Maybe<number>;
+    /** value string for option 1 e.g. Blue */
+    option1: Maybe<string>;
+    /** value string for option 2 e.g. Medium */
+    option2: Maybe<string>;
+    /** value string for option 3 */
+    option3: Maybe<string>;
+    /** sort position within the product */
+    position: number;
+    inventory_policy: ProductVariantInventoryPolicy;
+    inventory_quantity: number;
+    available: boolean;
+    /** array of images (only available if this variant has been merged from another product and if images are enabled in sync settings) */
+    images?: ElasticImage[];
+}
+export interface ElasticCollection {
+    /** legacy resource id */
+    id: number;
+    storefrontId: string;
+    handle: string;
+    title: string;
+    position: number;
+}
+export interface ElasticMetafield {
+    key: string;
+    type: string;
+    value: string;
+    namespace: string;
+    /**
+     * Legacy valueType attribute which is no longer provided by Shopify. We still
+     * populate this field to prevent any frontends breaking which rely on it.
+     *
+     * @see https://shopify.dev/apps/metafields/definitions/types
+     */
+    value_type: MetafieldValueType;
+}
+export interface ElasticPresentmentPrice {
+    /** decimal number e.g. 99.95 */
+    amount: number;
+    currency_code: string;
+}
+export interface ElasticImage {
+    /** originalSrc URL */
+    src: string;
+    /** alt text */
+    alt: Maybe<string>;
+}
+export interface ElasticCuration {
+    id: string;
+    hidden: boolean;
+    position?: number;
+    searchTerm?: string;
+    collectionHandle?: string;
+}
+export declare type ElasticBulkOperationUpdate = [
+    {
+        update: {
+            _index: string;
+            _id: string;
+        };
+    },
+    {
+        script?: {
+            lang: "painless";
+            source: string;
+            params?: Record<string, any>;
+        };
+        upsert?: Partial<ElasticProduct>;
+        scripted_upsert?: true;
+        doc?: Partial<ElasticProduct>;
+        doc_as_upsert?: true;
+    }
+];
+export declare type ElasticBulkOperationIndex = [
+    {
+        index: {
+            _index: string;
+            _id: string;
+        };
+    },
+    ElasticDocument
+];
+export declare type ElasticBulkOperation = ElasticBulkOperationUpdate | ElasticBulkOperationIndex;
+export declare type ElasticSearchResult<T = ElasticDocument> = {
+    hits: {
+        hits: ElasticHit<T>[];
+    };
+};
+export declare type ElasticHit<T = ElasticDocument> = {
+    _id: string;
+    _source: T;
+    _score: number | null;
+};
+export declare enum ElasticDataType {
+    Text = "text",
+    Long = "long",
+    Date = "date",
+    Float = "float",
+    Nested = "nested",
+    Keyword = "keyword",
+    Boolean = "boolean"
+}
+export interface ElasticProperty {
+    analyzer?: string;
+    type: ElasticDataType;
+    ignore_above?: number;
+    fields?: {
+        [key: string]: ElasticField;
+    };
+    properties?: {
+        [key: string]: ElasticProperty;
+    };
+}
+export interface ElasticField {
+    type: ElasticDataType;
+    ignore_above?: number;
+}