import { Boosting, Curation, CurationType, SearchableField } from "../types/firestore";
export declare const generateQueryCuratedPageSearch: (options: {
    curation: Curation & {
        type: CurationType.Search;
    };
    searchableFields: SearchableField[];
    market?: string;
}) => {
    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;
};
export declare const generateCuratedPageCollectionQuery: (options: {
    curation: Curation & {
        type: CurationType.Collection;
    };
    market?: string;
}) => {
    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;
    };
};
export declare const generateSearchFunctionScore: (options: {
    searchTerm: string;
    searchableFields: SearchableField[];
    boostingRules: Boosting[];
    markets: string[];
    market?: string;
}) => {
    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;
};
export declare const generateCollectionFunctionScore: (options: {
    collectionHandle: string;
    boostingRules: Boosting[];
    markets: string[];
    market?: string;
}) => {
    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;
};
