@thisisagile/easy-mongo/dist/Lucene.d.ts

Add support for MongoDB

import { DateTime, Func, List, OneOrMore, Optional, RequireAtLeastOne } from '@thisisagile/easy';
type FuzzyOptions = {
    maxEdits: number;
    prefixLength: number;
    maxExpansions: number;
};
export type Facet = {
    path: string;
    type: 'string';
    numBuckets: number;
} | {
    path: string;
    type: 'number';
    boundaries: number[];
    default?: string;
} | {
    path: string;
    type: 'date';
    boundaries: Date[];
    default?: string;
};
export type Operator = Func<Optional<object>, string>;
export type Clause = object | Operator;
export type Clauses = Record<string, Clause>;
export type SearchDefinition = Record<string, (v: string | number, q?: Record<string, string | number>) => RequireAtLeastOne<{
    should?: Clauses;
    filter?: Clauses;
    must?: Clauses;
    mustNot?: Clauses;
    sort?: Record<string, 1 | -1>;
    facet?: Facet;
}>>;
type Compound = {
    must: OneOrMore<Clauses>;
    should: OneOrMore<Clauses>;
    mustNot: OneOrMore<Clauses>;
    filter: OneOrMore<Clauses>;
};
export declare const lucene: {
    clause: (c: Clauses) => List<unknown>;
    clauses: (cs: OneOrMore<Clauses>) => unknown[];
    compound: (query: Record<string, string | number>, def: SearchDefinition, wildcard?: boolean) => Partial<Compound>;
    search: (c: Partial<Compound>, index?: string) => {
        $search: {
            compound: any;
            index?: string | undefined;
        };
    };
    searchWithDef: (query: Record<string, string | number>, options: SearchDefinition, count?: "total" | "lowerBound", index?: string) => {
        $search: {
            count: {
                type: "total" | "lowerBound";
            };
            sort?: Record<string, 1 | -1> | undefined;
            compound: Partial<Compound>;
            index?: string | undefined;
        };
    };
    searchMeta: (query: Record<string, string | number>, def: SearchDefinition, count?: "total" | "lowerBound", index?: string) => {
        $searchMeta: {
            count: {
                type: "total" | "lowerBound";
            };
            facet: {
                operator: {
                    compound: Partial<Compound>;
                };
                facets: {
                    [x: string]: Facet | undefined;
                };
            };
            compound?: undefined;
            index?: string | undefined;
        } | {
            count: {
                type: "total" | "lowerBound";
            };
            compound: Partial<Compound>;
            facet?: undefined;
            index?: string | undefined;
        };
    };
    exists: () => Operator;
    equals: (value: unknown) => Operator;
    text: (value?: OneOrMore<unknown>, fuzzy?: Partial<FuzzyOptions>) => Operator;
    wildcard: (value?: OneOrMore<unknown>, allowAnalyzedField?: boolean) => Operator;
    lt: (value: unknown) => Operator;
    lte: (value: unknown) => Operator;
    gt: (value: unknown) => Operator;
    gte: (value: unknown) => Operator;
    after: (date: unknown) => Operator;
    before: (date: unknown) => Operator;
    between: (after: unknown, before: unknown, includeLimit?: boolean) => Operator;
    facets: (def: SearchDefinition) => {
        [x: string]: Facet | undefined;
    };
    facet: {
        string: (path: string, numBuckets?: number) => Facet;
        number: (path: string, boundaries: List<number>, alt?: string) => Facet;
        date: (path: string, boundaries: List<DateTime>, alt?: string) => Facet;
    };
};
export {};