import { SearchTypes } from "@medusajs/framework/types";
import { SearchIndexes } from "../types";
export declare enum SearchIndexState {
    PENDING = "pending",
    BUILDING = "building",
    READY = "ready",
    ERROR = "error"
}
export declare enum SearchSyncStatus {
    PENDING = "pending",
    PROCESSING = "processing",
    DONE = "done",
    FAILED = "failed",
    CANCELED = "canceled"
}
export declare const DEFAULT_REINDEX_BATCH_SIZE = 100;
export type FlatSearchField = {
    path: string;
    field: SearchTypes.SearchFieldDefinition;
};
export declare function flattenFields(fields: Record<string, SearchTypes.SearchFieldDefinition>, prefix?: string): FlatSearchField[];
export declare function isSearchable(field: SearchTypes.SearchFieldDefinition): boolean;
export declare function isFacetable(field: SearchTypes.SearchFieldDefinition, kind: SearchTypes.SearchFacetKind): boolean;
/**
 * The dotted paths an index can hand back on hits. Object containers are
 * excluded — only their declared leaves are stored, so returning the container
 * would silently hand back a partial object.
 */
export declare function listRetrievablePaths(fields: Record<string, SearchTypes.SearchFieldDefinition>): string[];
export declare function normalizeSearchQuery({ query, index, }: {
    query: SearchTypes.SearchQuery;
    index: SearchTypes.ResolvedSearchIndexDefinition;
}): SearchTypes.ProviderSearchQuery;
/**
 * The base query plus one per faceted field with that field's own filter dropped.
 * Every engine reviewed needs a query per facet, so the fan-out lives here rather
 * than in each provider. `disjunctive_facets` is stripped from what is handed on —
 * a provider should never see an option it is not expected to act on.
 */
export declare function buildDisjunctiveFacetQueries(query: SearchTypes.ProviderSearchQuery): {
    base: SearchTypes.ProviderSearchQuery;
    per_facet: Map<string, SearchTypes.ProviderSearchQuery>;
};
export declare function mergeDisjunctiveFacetResults({ base, per_facet, }: {
    base: SearchTypes.SearchResult;
    per_facet: Map<string, SearchTypes.SearchResult>;
}): SearchTypes.SearchResult;
export declare function validateFieldUsage({ index, query, }: {
    index: SearchTypes.ResolvedSearchIndexDefinition;
    query: Pick<SearchTypes.SearchQuery, "filters" | "pagination" | "search_options">;
}): void;
/**
 * Resolves every definition once, at construction. Duplicates and incoherent
 * definitions fail here, so everything downstream can treat the result as given.
 */
export declare function resolveIndexDefinitions({ definitions, default_provider, index_prefix, }: {
    definitions: SearchTypes.SearchIndexDefinition[];
    default_provider: string;
    index_prefix?: string;
}): SearchIndexes;
export declare function retrieveIndexDefinition(indexes: SearchIndexes, name: string): SearchTypes.ResolvedSearchIndexDefinition;
export declare function assertTaskAccepted(task: SearchTypes.SearchTask, index: string): SearchTypes.SearchTask;
//# sourceMappingURL=index.d.ts.map