import { ReactiveList } from "@usereactify/search-internals";
import { ReactifySearchProviderProps } from "../components";
import { Config, ConfigFilter, ConfigFilterFacet, ResultsDataListener } from "../types";
export type GeneratePropsFilterGroupOptions = {
    provider: ReactifySearchProviderProps;
    config: Config;
    filterGroup?: ConfigFilter;
    query?: Record<string, string>;
};
export type GeneratePropsSensorOptions = {
    provider: ReactifySearchProviderProps;
    config: Config;
    query?: Record<string, string>;
};
export type GeneratePropsBase = {
    provider: ReactifySearchProviderProps;
    config: Config;
    query?: Record<string, string>;
};
export declare const getPropsFilterGroup: (options: GeneratePropsFilterGroupOptions) => ({
    size: number;
    URLParams: boolean;
    showLoader: boolean;
    dataField: string;
    showResultStats: boolean;
    react: {
        and: string[];
    };
    includeFields: string[];
    excludeFields: string[];
    scrollTarget: string | Element | HTMLDocument | undefined;
    componentId: string;
    scrollOnChange: boolean;
    pagination: boolean;
    infiniteScroll: boolean;
    renderNoResults: () => null;
    source: typeof ReactiveList;
    onData: ResultsDataListener | undefined;
} | {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => unknown;
} | {
    URLParams: boolean;
    componentId: string;
    dataField: string;
    filterLabel: string;
    nestedField: string | undefined;
    customQuery: ((value?: string | string[]) => {
        query?: undefined;
    } | {
        query: {
            nested: {
                path: string;
                query: {
                    bool: {
                        must: ({
                            match: {
                                "variants.available": string;
                            };
                            terms?: undefined;
                        } | {
                            terms: {
                                [x: string]: string[];
                            };
                            match?: undefined;
                        })[];
                    };
                };
            };
        };
    }) | undefined;
    defaultQuery: (() => {
        aggs: {
            reactivesearch_nested: {
                nested: {
                    path: string;
                };
                aggs: {
                    reactify_nested_outer: {
                        filter: {
                            bool: {
                                minimum_should_match: number;
                                should: {
                                    match: {
                                        "variants.available": string;
                                    };
                                }[];
                            };
                        };
                        aggs: {
                            [x: string]: {
                                terms: {
                                    field: string;
                                    size: number;
                                    order: {
                                        _count: string;
                                    };
                                };
                                aggs: {
                                    parent_docs: {
                                        reverse_nested: {};
                                    };
                                };
                            };
                        };
                    };
                };
            };
        };
    }) | undefined;
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/range/SingleRange").SingleRangeProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/list/SingleList").SingleList, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/range/MultiRange").MultiRangeProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/list/MultiList").MultiList, any> | undefined;
    react: {
        and: string[];
    };
} | null)[];
export declare const getPropsFilterGroupOption: (options: GeneratePropsFilterGroupOptions, filterGroupOption: ConfigFilterFacet) => {
    URLParams: boolean;
    componentId: string;
    dataField: string;
    filterLabel: string;
    nestedField: string | undefined;
    customQuery: ((value?: string | string[]) => {
        query?: undefined;
    } | {
        query: {
            nested: {
                path: string;
                query: {
                    bool: {
                        must: ({
                            match: {
                                "variants.available": string;
                            };
                            terms?: undefined;
                        } | {
                            terms: {
                                [x: string]: string[];
                            };
                            match?: undefined;
                        })[];
                    };
                };
            };
        };
    }) | undefined;
    defaultQuery: (() => {
        aggs: {
            reactivesearch_nested: {
                nested: {
                    path: string;
                };
                aggs: {
                    reactify_nested_outer: {
                        filter: {
                            bool: {
                                minimum_should_match: number;
                                should: {
                                    match: {
                                        "variants.available": string;
                                    };
                                }[];
                            };
                        };
                        aggs: {
                            [x: string]: {
                                terms: {
                                    field: string;
                                    size: number;
                                    order: {
                                        _count: string;
                                    };
                                };
                                aggs: {
                                    parent_docs: {
                                        reverse_nested: {};
                                    };
                                };
                            };
                        };
                    };
                };
            };
        };
    }) | undefined;
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/range/SingleRange").SingleRangeProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/list/SingleList").SingleList, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/range/MultiRange").MultiRangeProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/list/MultiList").MultiList, any> | undefined;
    react: {
        and: string[];
    };
};
export declare const getPropsSensors: (options: GeneratePropsSensorOptions) => ({
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => unknown;
} | null)[];
export declare const getPropsSensorCustom: (options: GeneratePropsSensorOptions) => {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => unknown;
}[];
export declare const getPropsSensorCollection: (options: GeneratePropsSensorOptions) => {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => {
        query: {
            bool: {
                should: ({
                    nested: {
                        path: string;
                        query: {
                            term: {
                                "collections.handle.keyword": string;
                                "curations.collectionHandle.keyword"?: undefined;
                            };
                        };
                    };
                } | {
                    nested: {
                        path: string;
                        query: {
                            term: {
                                "curations.collectionHandle.keyword": string;
                                "collections.handle.keyword"?: undefined;
                            };
                        };
                    };
                })[];
            };
        };
    } | null;
} | null;
export declare const getPropsSensorCuratedPageCollection: ({ provider, config, }: GeneratePropsSensorOptions) => {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => {
        query: {
            function_score: {
                query: {
                    bool: {
                        must: Record<string, any>[];
                    };
                };
                functions: ({
                    filter: {
                        wildcard: {
                            [x: string]: string;
                        };
                        bool?: undefined;
                        term?: undefined;
                        range?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        bool: {
                            must_not: {
                                wildcard: {
                                    [x: string]: string;
                                };
                            };
                        };
                        wildcard?: undefined;
                        term?: undefined;
                        range?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        term: {
                            [x: string]: string;
                        };
                        wildcard?: undefined;
                        bool?: undefined;
                        range?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        range: {
                            [x: string]: {
                                gt: number;
                            };
                        };
                        wildcard?: undefined;
                        bool?: undefined;
                        term?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        range: {
                            [x: string]: {
                                lt: number;
                            };
                        };
                        wildcard?: undefined;
                        bool?: undefined;
                        term?: undefined;
                    };
                    weight: number;
                })[];
                score_mode: string;
                boost_mode: string;
            };
        };
    };
} | null;
export declare const getPropsSensorCuratedPageSearch: ({ provider, config, }: GeneratePropsSensorOptions) => {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => {
        query: {
            function_score: {
                query: {
                    bool: {
                        should: {
                            match: {
                                [x: string]: {
                                    query: string;
                                    fuzziness: number;
                                    analyzer: string;
                                };
                            };
                        }[];
                        terms?: {
                            markets: string[];
                        } | undefined;
                    };
                };
                functions: ({
                    filter: {
                        wildcard: {
                            [x: string]: string;
                        };
                        bool?: undefined;
                        term?: undefined;
                        range?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        bool: {
                            must_not: {
                                wildcard: {
                                    [x: string]: string;
                                };
                            };
                        };
                        wildcard?: undefined;
                        term?: undefined;
                        range?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        term: {
                            [x: string]: string;
                        };
                        wildcard?: undefined;
                        bool?: undefined;
                        range?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        range: {
                            [x: string]: {
                                gt: number;
                            };
                        };
                        wildcard?: undefined;
                        bool?: undefined;
                        term?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        range: {
                            [x: string]: {
                                lt: number;
                            };
                        };
                        wildcard?: undefined;
                        bool?: undefined;
                        term?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        match: {
                            [x: string]: {
                                query: string;
                                fuzziness: number;
                                analyzer: string;
                            };
                        };
                        bool?: undefined;
                    };
                    weight: number;
                } | {
                    filter: {
                        bool: {
                            must_not: {
                                match: {
                                    [x: string]: {
                                        query: string;
                                        fuzziness: number;
                                        analyzer: string;
                                    };
                                };
                            };
                            should: {
                                match: {
                                    [x: string]: {
                                        query: string;
                                        fuzziness: number;
                                    };
                                };
                            };
                        };
                        match?: undefined;
                    };
                    weight: number;
                })[];
                score_mode: string;
                boost_mode: string;
            };
        };
    } | null;
} | null;
export declare const getPropsSensorPublished: (options: GeneratePropsSensorOptions) => {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => {
        query: {
            bool: {
                must: ({
                    match: {
                        markets: string;
                        published?: undefined;
                    };
                } | {
                    match: {
                        published: boolean;
                        markets?: undefined;
                    };
                })[];
            };
            match?: undefined;
        };
    } | {
        query: {
            match: {
                published: boolean;
            };
            bool?: undefined;
        };
    };
};
export declare const getPropsSensorInventoryAvailable: (options: GeneratePropsSensorOptions) => {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => {
        query: {
            bool: {
                should: ({
                    bool: {
                        must: ({
                            term: {
                                type: {
                                    value: string;
                                };
                            };
                            nested?: undefined;
                        } | {
                            nested: {
                                path: string;
                                query: {
                                    match: {
                                        [x: string]: boolean;
                                    };
                                };
                            };
                            term?: undefined;
                        })[];
                    };
                    term?: undefined;
                } | {
                    term: {
                        type: {
                            value: string;
                        };
                    };
                    bool?: undefined;
                })[];
                minimum_should_match: string;
            };
        };
    };
} | null;
export declare const getPropsSensorSort: (options: GeneratePropsSensorOptions & {
    searchTerm?: string;
    sortOption?: string;
}) => {
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any>;
    componentId: string;
    customQuery: () => {
        sort: any[];
        query: Record<string, any> | undefined;
    };
};
export declare const getPropsBase: (options: GeneratePropsBase) => {
    app: string;
    url: string;
    credentials: string | undefined;
    theme: Record<string, unknown> | undefined;
    initialState: unknown;
    transformSort: () => any[];
    transformRequest: (request: any) => any;
    transformResponse: (response: any) => Promise<any>;
    headers: {
        "x-reactify-shop": string;
        "x-reactify-mode": "search" | "collection" | "instant-search" | "curated-page";
        "x-reactify-client-id": string | undefined;
        "x-reactify-client-version": string;
    };
};
export declare const getPropsResults: (options: GeneratePropsFilterGroupOptions & {
    scrollTarget?: string | Element | HTMLDocument;
    pageSize?: number;
    onData?: ResultsDataListener;
}) => {
    size: number;
    URLParams: boolean;
    showLoader: boolean;
    dataField: string;
    showResultStats: boolean;
    react: {
        and: string[];
    };
    includeFields: string[];
    excludeFields: string[];
    scrollTarget: string | Element | HTMLDocument | undefined;
    componentId: string;
    scrollOnChange: boolean;
    pagination: boolean;
    infiniteScroll: boolean;
    renderNoResults: () => null;
    source: typeof ReactiveList;
    onData: ResultsDataListener | undefined;
};
export declare const getPropsReact: (options: GeneratePropsFilterGroupOptions, filterGroupOption?: ConfigFilterFacet) => {
    and: string[];
};
export declare const getPropsShared: (options: GeneratePropsFilterGroupOptions, filterGroupOption: ConfigFilterFacet) => {
    URLParams: boolean;
    componentId: string;
    dataField: string;
    filterLabel: string;
    nestedField: string | undefined;
    customQuery: ((value?: string | string[]) => {
        query?: undefined;
    } | {
        query: {
            nested: {
                path: string;
                query: {
                    bool: {
                        must: ({
                            match: {
                                "variants.available": string;
                            };
                            terms?: undefined;
                        } | {
                            terms: {
                                [x: string]: string[];
                            };
                            match?: undefined;
                        })[];
                    };
                };
            };
        };
    }) | undefined;
    defaultQuery: (() => {
        aggs: {
            reactivesearch_nested: {
                nested: {
                    path: string;
                };
                aggs: {
                    reactify_nested_outer: {
                        filter: {
                            bool: {
                                minimum_should_match: number;
                                should: {
                                    match: {
                                        "variants.available": string;
                                    };
                                }[];
                            };
                        };
                        aggs: {
                            [x: string]: {
                                terms: {
                                    field: string;
                                    size: number;
                                    order: {
                                        _count: string;
                                    };
                                };
                                aggs: {
                                    parent_docs: {
                                        reverse_nested: {};
                                    };
                                };
                            };
                        };
                    };
                };
            };
        };
    }) | undefined;
    source: import("react").ComponentClass<import("@usereactify/search-internals/lib/components/basic/ReactiveComponent").ReactiveComponentProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/range/SingleRange").SingleRangeProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/list/SingleList").SingleList, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/range/MultiRange").MultiRangeProps, any> | import("react").ComponentClass<import("@usereactify/search-internals/lib/components/list/MultiList").MultiList, any> | undefined;
    react: {
        and: string[];
    };
};
export declare const getPropsFilterList: (filterGroupOption: ConfigFilterFacet) => {
    size: number | undefined;
    queryFormat: "and" | "or";
    showFilter: boolean;
    showLoadMore: boolean;
    showSearch: boolean;
    showRadio: boolean;
    showCheckbox: boolean;
};
export declare const getPropsFilterRange: (filterGroupOption: ConfigFilterFacet) => {
    queryFormat: "and" | "or";
    showFilter: boolean;
    showRadio: boolean;
    showCheckbox: boolean;
    data: {
        label: string;
        start: number;
        end: number;
    }[];
};
export declare const getPropsFilterSlider: (filterGroupOption: ConfigFilterFacet, query: Record<string, string> | string, value?: [number, number] | []) => {
    defaultQuery: {
        aggs: {
            min: {
                min: {
                    field: string;
                };
            };
            max: {
                max: {
                    field: string;
                };
            };
        };
    };
    customQuery: {
        query: {
            bool: {
                must: {
                    bool: {
                        must: ({
                            match: {
                                published: boolean;
                            };
                            range?: undefined;
                        } | {
                            range: {
                                [x: string]: {
                                    gte: any;
                                    lte: any;
                                    boost: number;
                                };
                            };
                            match?: undefined;
                        })[];
                    };
                }[];
            };
        };
    } | undefined;
};
