import React from 'react';
import ReactDOM from 'react-dom/client';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as styled_components from 'styled-components';

type Options$1 = Field$1[];
type Field$1 = {
    field: string;
    id: number;
    isDefault: boolean;
    type: string;
    label: string;
    translationMap: {
        "label.en_US"?: string;
        "label.es_ES"?: string;
        "label.it_IT"?: string;
    };
};

declare const OpenK9ClientContext: React.Context<{
    authInit: Promise<boolean> | null;
    authenticate({ token }: {
        token?: string;
    }): Promise<void>;
    deauthenticate(): Promise<void>;
    getUserProfile(): Promise<{}>;
    getGenerateResponse({ searchQuery, controller, }: {
        searchQuery: GenerateRequest;
        controller: AbortController;
    }): Promise<Response>;
    getServiceStatus(): Promise<"up" | "down">;
    doSearch<E>(searchRequest: SearchRequest): Promise<SearchResult<E>>;
    generateResponse<E>(searchRequest: GenerateRequest): Promise<any>;
    getDateFilterFields(): Promise<{
        id: number;
        field: string;
        label: string;
    }[]>;
    getLabelSort(): Promise<{
        field: string;
        id: number;
        label: string;
    }[]>;
    getLanguages(): Promise<{
        createDate: any;
        modifiedDate: any;
        id: number;
        name: string;
        value: "value";
    }[]>;
    getSortingInfo(): Promise<{
        field: string;
        id: number;
        isDefault: boolean;
        type: string;
        label: string;
        translationMap: {
            "label.en_US"?: string;
            "label.es_ES"?: string;
            "label.it_IT"?: string;
        };
    }[]>;
    getRefreshFilters(): Promise<{
        retrieveType: string;
        refreshOnSuggestionCategory: boolean;
        refreshOnTab: boolean;
        refreshOnDate: boolean;
        refreshOnQuery: boolean;
    }>;
    getLanguageDefault(): Promise<{
        value: string;
    }>;
    getSuggestions({ searchQuery, suggestionCategoryId, range, afterKey, suggestKeyword, order, language, }: {
        searchQuery: SearchToken[];
        suggestionCategoryId?: number;
        range?: [number, number];
        afterKey?: string;
        suggestKeyword?: string;
        order: "desc" | "asc";
        language: string;
    }): Promise<{
        result: SuggestionResult[];
        afterKey: string;
    }>;
    getAutocompletes({ searchText, }: {
        searchText: string;
    }): Promise<AutocompleteResponse>;
    handle_dynamic_filters(): Promise<{
        handleDynamicFilters: boolean;
    }>;
    getSuggestionCategories(): Promise<SuggestionsCategoriesResult>;
    getTabsByVirtualHost(): Promise<Array<{
        label: string;
        tokens: Array<SearchToken>;
        translationMap: {
            [key: string]: string;
        };
        sortings: Options$1;
    }>>;
    getTemplatesByVirtualHost(): Promise<Array<string>>;
    loadTemplate<E>(id: string): Promise<Template<E> | null>;
    fetchQueryAnalysis(request: AnalysisRequest): Promise<AnalysisResponse | null>;
}>;
declare function useOpenK9Client(): {
    authInit: Promise<boolean> | null;
    authenticate({ token }: {
        token?: string;
    }): Promise<void>;
    deauthenticate(): Promise<void>;
    getUserProfile(): Promise<{}>;
    getGenerateResponse({ searchQuery, controller, }: {
        searchQuery: GenerateRequest;
        controller: AbortController;
    }): Promise<Response>;
    getServiceStatus(): Promise<"up" | "down">;
    doSearch<E>(searchRequest: SearchRequest): Promise<SearchResult<E>>;
    generateResponse<E>(searchRequest: GenerateRequest): Promise<any>;
    getDateFilterFields(): Promise<{
        id: number;
        field: string;
        label: string;
    }[]>;
    getLabelSort(): Promise<{
        field: string;
        id: number;
        label: string;
    }[]>;
    getLanguages(): Promise<{
        createDate: any;
        modifiedDate: any;
        id: number;
        name: string;
        value: "value";
    }[]>;
    getSortingInfo(): Promise<{
        field: string;
        id: number;
        isDefault: boolean;
        type: string;
        label: string;
        translationMap: {
            "label.en_US"?: string;
            "label.es_ES"?: string;
            "label.it_IT"?: string;
        };
    }[]>;
    getRefreshFilters(): Promise<{
        retrieveType: string;
        refreshOnSuggestionCategory: boolean;
        refreshOnTab: boolean;
        refreshOnDate: boolean;
        refreshOnQuery: boolean;
    }>;
    getLanguageDefault(): Promise<{
        value: string;
    }>;
    getSuggestions({ searchQuery, suggestionCategoryId, range, afterKey, suggestKeyword, order, language, }: {
        searchQuery: SearchToken[];
        suggestionCategoryId?: number;
        range?: [number, number];
        afterKey?: string;
        suggestKeyword?: string;
        order: "desc" | "asc";
        language: string;
    }): Promise<{
        result: SuggestionResult[];
        afterKey: string;
    }>;
    getAutocompletes({ searchText, }: {
        searchText: string;
    }): Promise<AutocompleteResponse>;
    handle_dynamic_filters(): Promise<{
        handleDynamicFilters: boolean;
    }>;
    getSuggestionCategories(): Promise<SuggestionsCategoriesResult>;
    getTabsByVirtualHost(): Promise<Array<{
        label: string;
        tokens: Array<SearchToken>;
        translationMap: {
            [key: string]: string;
        };
        sortings: Options$1;
    }>>;
    getTemplatesByVirtualHost(): Promise<Array<string>>;
    loadTemplate<E>(id: string): Promise<Template<E> | null>;
    fetchQueryAnalysis(request: AnalysisRequest): Promise<AnalysisResponse | null>;
};
declare global {
    interface Window {
        KEYCLOAK_URL: string;
        KEYCLOAK_REALM: string;
        KEYCLOAK_CLIENT_ID: string;
    }
}
declare function OpenK9Client({ onAuthenticated, tenant, useKeycloak, waitKeycloackForToken, callback, }: {
    onAuthenticated(): void;
    tenant: string;
    useKeycloak?: boolean;
    waitKeycloackForToken: boolean;
    callback(): void | null | undefined;
}): {
    authInit: Promise<boolean> | null;
    authenticate({ token }: {
        token?: string;
    }): Promise<void>;
    deauthenticate(): Promise<void>;
    getUserProfile(): Promise<{}>;
    getGenerateResponse({ searchQuery, controller, }: {
        searchQuery: GenerateRequest;
        controller: AbortController;
    }): Promise<Response>;
    getServiceStatus(): Promise<"up" | "down">;
    doSearch<E>(searchRequest: SearchRequest): Promise<SearchResult<E>>;
    generateResponse<E>(searchRequest: GenerateRequest): Promise<any>;
    getDateFilterFields(): Promise<{
        id: number;
        field: string;
        label: string;
    }[]>;
    getLabelSort(): Promise<{
        field: string;
        id: number;
        label: string;
    }[]>;
    getLanguages(): Promise<{
        createDate: any;
        modifiedDate: any;
        id: number;
        name: string;
        value: "value";
    }[]>;
    getSortingInfo(): Promise<{
        field: string;
        id: number;
        isDefault: boolean;
        type: string;
        label: string;
        translationMap: {
            "label.en_US"?: string;
            "label.es_ES"?: string;
            "label.it_IT"?: string;
        };
    }[]>;
    getRefreshFilters(): Promise<{
        retrieveType: string;
        refreshOnSuggestionCategory: boolean;
        refreshOnTab: boolean;
        refreshOnDate: boolean;
        refreshOnQuery: boolean;
    }>;
    getLanguageDefault(): Promise<{
        value: string;
    }>;
    getSuggestions({ searchQuery, suggestionCategoryId, range, afterKey, suggestKeyword, order, language, }: {
        searchQuery: SearchToken[];
        suggestionCategoryId?: number;
        range?: [number, number];
        afterKey?: string;
        suggestKeyword?: string;
        order: "desc" | "asc";
        language: string;
    }): Promise<{
        result: SuggestionResult[];
        afterKey: string;
    }>;
    getAutocompletes({ searchText, }: {
        searchText: string;
    }): Promise<AutocompleteResponse>;
    handle_dynamic_filters(): Promise<{
        handleDynamicFilters: boolean;
    }>;
    getSuggestionCategories(): Promise<SuggestionsCategoriesResult>;
    getTabsByVirtualHost(): Promise<Array<{
        label: string;
        tokens: Array<SearchToken>;
        translationMap: {
            [key: string]: string;
        };
        sortings: Options$1;
    }>>;
    getTemplatesByVirtualHost(): Promise<Array<string>>;
    loadTemplate<E>(id: string): Promise<Template<E> | null>;
    fetchQueryAnalysis(request: AnalysisRequest): Promise<AnalysisResponse | null>;
};
type GenericResultItem<E = {}> = {
    source: {
        documentTypes: (keyof E)[];
        contentId: string;
        id: string;
        parsingDate: number;
        rawContent: string;
        tenantId: number;
        datasourceId: number;
        entities?: Array<{
            entityType: string;
            context: DeepKeys<Without<GenericResultItem<E>["source"], "entities">>[];
            id: string;
        }>;
        resources: {
            binaries: {
                id: string;
                name: string;
                contentType: string;
                resourceId: string;
            }[];
        };
    } & E;
    highlight: {
        [field in GenericResultItemFields<E>]?: string[];
    };
    sortAfterKey: string;
};
type GenericResultItemFields<E> = DeepKeys<Without<GenericResultItem<E>["source"], "type" | "entities">>;
type PathImpl<T, Key extends keyof T> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}` | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}` : never : never;
type PathImpl2<T> = PathImpl<T, keyof T> | keyof T;
type DeepKeys<T> = PathImpl2<T> extends string | keyof T ? PathImpl2<T> : keyof T;
type Without<T, K> = Pick<T, Exclude<keyof T, K>>;
type Template<E> = {
    resultType: string;
    priority: number;
    result: React.FC<ResultRendererProps<E>>;
    detail: React.FC<DetailRendererProps<E>>;
};
type ResultRendererProps<E> = {
    result: GenericResultItem<E>;
};
type DetailRendererProps<E> = {
    result: GenericResultItem<E>;
};
type SearchToken = {
    tokenType: "DATASOURCE";
    keywordKey?: undefined;
    values: string[];
    filter: boolean;
    suggestionCategoryId?: number;
    count?: string;
    isTab?: boolean;
    isFilter?: boolean;
    search?: boolean;
} | {
    tokenType: "DOCTYPE";
    keywordKey: "type";
    values: string[];
    filter: boolean;
    suggestionCategoryId?: number;
    count?: string;
    isTab?: boolean;
    isFilter?: boolean;
    search?: boolean;
} | {
    tokenType: "TEXT";
    keywordKey?: string;
    values: string[];
    filter: boolean;
    goToSuggestion?: boolean;
    overrideSearchWithCorrection?: boolean;
    label?: string;
    suggestionCategoryId?: number;
    count?: string;
    isTab?: boolean;
    isFilter?: boolean;
    search?: boolean;
    extra?: {
        boost?: string;
        fuzziness?: string;
    };
} | {
    tokenType: "ENTITY";
    keywordKey?: string;
    entityType: string;
    entityName: string;
    values: string[];
    filter: boolean;
    suggestionCategoryId?: number;
    count?: string;
    isTab?: boolean;
    isFilter?: boolean;
    search?: boolean;
} | {
    tokenType: "DATE";
    keywordKey?: string;
    extra: {
        gte: number;
        lte: number;
    };
    suggestionCategoryId?: number;
    count?: string;
    values?: string[];
    isTab?: boolean;
    isFilter?: boolean;
    search?: boolean;
} | {
    tokenType: "FILTER";
    keywordKey?: string;
    values: string[];
    filter: boolean;
    goToSuggestion?: boolean;
    label?: string;
    suggestionCategoryId?: number;
    count?: string;
    isTab?: boolean;
    isFilter?: boolean;
    search?: boolean;
};
type SortField = {
    [key: string]: {
        sort: "asc" | "desc";
        missing: "_last";
    };
};
type AutocompleteResponseWrapped = {
    items: AutocompleteSuggestion[];
};
type AutocompleteSuggestion = {
    autocomplete: string;
    labelDocType: string;
};
type AutocompleteResponse = AutocompleteSuggestion[];
type AutocompleteRequest = {
    queryText: string;
};
type AutocompleteEsQuery = {
    _source: {
        includes: Array<"web.title" | "web.productName" | string>;
    };
    query: {
        multi_match: {
            fields: Array<"web.title.searchasyou" | "web.productName.searchasyou" | string>;
            fuzziness: "AUTO" | number | string;
            minimum_should_match: string;
            operator: "or" | "and";
            query: string;
            type: "bool_prefix";
        };
    };
    size: number;
    sort: Array<{
        _score: {
            order: "asc" | "desc";
        };
    }>;
};
type SearchRequest = {
    searchQuery: Array<SearchToken>;
    range: [number, number];
    sort: SortField[];
    language: string;
    sortAfterKey: string;
    overrideSearchWithCorrection?: boolean;
};
type GenerateRequest = {
    searchQuery: Array<SearchToken>;
    range: [number, number];
    sort: SortField[];
    language: string;
    sortAfterKey: string;
    searchText: string;
};
type SearchResult<E> = {
    result: Array<GenericResultItem<E>>;
    total: number;
    autocorrection: AutocorrectionType;
};
type AutocorrectionType = {
    originalText: string;
    searchedWithCorrectedText: boolean;
    autocorrectionText: string;
    suggestions: [
        {
            offset: number;
            length: number;
            text: string;
            correction: string;
        }
    ];
};
type AnalysisToken = {
    tokenType: "DOCTYPE";
    value: string;
    label: string;
} | {
    tokenType: "DATASOURCE";
    value: string;
    label: string;
} | {
    tokenType: "ENTITY";
    entityType: string;
    entityName: string;
    keywordKey?: string;
    value: string;
    label: string;
} | {
    tokenType: "TEXT";
    keywordKey?: string;
    keywordName?: string;
    value: string;
    label: string;
    extra?: {
        boost?: string;
        fuzziness?: string;
    };
} | {
    tokenType: "AUTOCORRECT";
    value: string;
    label: string;
} | {
    tokenType: "AUTOCOMPLETE";
    value: string;
    label: string;
} | {
    tokenType: "FILTER";
    keywordKey?: string;
    keywordName?: string;
    value: string;
    label: string;
};
type AnalysisRequest = {
    searchText: string;
    tokens: Array<AnalysisRequestEntry>;
};
type AnalysisRequestEntry = {
    text: string;
    start: number;
    end: number;
    token: AnalysisToken;
};
type AnalysisResponse = {
    searchText: string;
    analysis: Array<AnalysisResponseEntry>;
};
type AnalysisResponseEntry = {
    text: string;
    start: number;
    end: number;
    tokens: Array<AnalysisToken & {
        score: number;
    }>;
};
type SuggestionResult = {
    tokenType: "DATASOURCE";
    suggestionCategoryId: number;
    value: string;
    keywordKey?: string;
    count?: string;
} | {
    tokenType: "TEXT";
    suggestionCategoryId: number;
    keywordKey?: string;
    value: string;
    count?: string;
} | {
    tokenType: "ENTITY";
    suggestionCategoryId: number;
    entityType: string;
    entityValue: string;
    keywordKey?: string;
    value: string;
    count?: string;
} | {
    tokenType: "DOCTYPE";
    suggestionCategoryId: number;
    value: string;
    keywordKey?: string;
    count?: string;
} | {
    tokenType: "FILTER";
    suggestionCategoryId: number;
    keywordKey?: string;
    value: string;
    count?: string;
};
type SuggestionsCategoriesResult = Array<{
    name: string;
    id: number;
    multiSelect: boolean;
    translationMap: {
        [key: string]: string;
    };
}>;

type RestApi_AnalysisRequest = AnalysisRequest;
type RestApi_AnalysisRequestEntry = AnalysisRequestEntry;
type RestApi_AnalysisResponse = AnalysisResponse;
type RestApi_AnalysisResponseEntry = AnalysisResponseEntry;
type RestApi_AnalysisToken = AnalysisToken;
type RestApi_AutocompleteEsQuery = AutocompleteEsQuery;
type RestApi_AutocompleteRequest = AutocompleteRequest;
type RestApi_AutocompleteResponse = AutocompleteResponse;
type RestApi_AutocompleteResponseWrapped = AutocompleteResponseWrapped;
type RestApi_AutocompleteSuggestion = AutocompleteSuggestion;
type RestApi_AutocorrectionType = AutocorrectionType;
type RestApi_DetailRendererProps<E> = DetailRendererProps<E>;
type RestApi_GenerateRequest = GenerateRequest;
type RestApi_GenericResultItem<E = {}> = GenericResultItem<E>;
type RestApi_GenericResultItemFields<E> = GenericResultItemFields<E>;
declare const RestApi_OpenK9Client: typeof OpenK9Client;
declare const RestApi_OpenK9ClientContext: typeof OpenK9ClientContext;
type RestApi_ResultRendererProps<E> = ResultRendererProps<E>;
type RestApi_SearchToken = SearchToken;
type RestApi_SortField = SortField;
type RestApi_SuggestionResult = SuggestionResult;
type RestApi_Template<E> = Template<E>;
declare const RestApi_useOpenK9Client: typeof useOpenK9Client;
declare namespace RestApi {
  export { RestApi_OpenK9Client as OpenK9Client, RestApi_OpenK9ClientContext as OpenK9ClientContext, RestApi_useOpenK9Client as useOpenK9Client };
  export type { RestApi_AnalysisRequest as AnalysisRequest, RestApi_AnalysisRequestEntry as AnalysisRequestEntry, RestApi_AnalysisResponse as AnalysisResponse, RestApi_AnalysisResponseEntry as AnalysisResponseEntry, RestApi_AnalysisToken as AnalysisToken, RestApi_AutocompleteEsQuery as AutocompleteEsQuery, RestApi_AutocompleteRequest as AutocompleteRequest, RestApi_AutocompleteResponse as AutocompleteResponse, RestApi_AutocompleteResponseWrapped as AutocompleteResponseWrapped, RestApi_AutocompleteSuggestion as AutocompleteSuggestion, RestApi_AutocorrectionType as AutocorrectionType, RestApi_DetailRendererProps as DetailRendererProps, RestApi_GenerateRequest as GenerateRequest, RestApi_GenericResultItem as GenericResultItem, RestApi_GenericResultItemFields as GenericResultItemFields, RestApi_ResultRendererProps as ResultRendererProps, RestApi_SearchToken as SearchToken, RestApi_SortField as SortField, RestApi_SuggestionResult as SuggestionResult, RestApi_Template as Template };
}

type BadgeProps = {
    children: React.ReactNode;
};
declare function Badge({ children }: BadgeProps): react_jsx_runtime.JSX.Element;

type BadgeContainerProps = {
    children: React.ReactNode;
};
declare function BadgeContainer({ children }: BadgeContainerProps): react_jsx_runtime.JSX.Element;

type ChipProps = {
    title: string;
    customStyles?: CustomStyles;
};
type CustomStyles = {
    button?: React.CSSProperties;
    div?: React.CSSProperties;
};
declare function Chip({ title, customStyles }: ChipProps): react_jsx_runtime.JSX.Element;

type DateCardProps<E> = {
    result: GenericResultItem<E>;
    label?: string;
    path: string;
};
declare function DateCard<E>({ result, label, path, }: DateCardProps<E>): react_jsx_runtime.JSX.Element;

type DetailAttributeProps = {
    label: string;
    children: React.ReactNode;
};
declare function DetailAttribute({ label, children }: DetailAttributeProps): react_jsx_runtime.JSX.Element;

type DetailContainerProps = {
    children: React.ReactNode;
};
declare function DetailContainer({ children }: DetailContainerProps): react_jsx_runtime.JSX.Element;

type DetailFaviconProps = {
    src: string;
};
declare function DetailFavicon({ src }: DetailFaviconProps): react_jsx_runtime.JSX.Element;

type DetailHeaderImageProps = {
    src: string;
};
declare function DetailHeaderImage({ src }: DetailHeaderImageProps): react_jsx_runtime.JSX.Element;

type DetailIconContainerProps = {
    children: React.ReactNode;
};
declare function DetailIconContainer({ children }: DetailIconContainerProps): react_jsx_runtime.JSX.Element;

type DetailLinkProps = {
    href: string;
    children: React.ReactNode;
};
declare function DetailLink({ href, children }: DetailLinkProps): react_jsx_runtime.JSX.Element;

type DetailTextContentProps$1<E> = {
    result: GenericResultItem<E>;
    path: GenericResultItemFields<E>;
    isHighlighted?: boolean;
};
declare function DetailTextContent<E>({ result, path, isHighlighted, }: DetailTextContentProps$1<E>): react_jsx_runtime.JSX.Element | null;

type DetailTextContentProps<E> = {
    result: GenericResultItem<E>;
    path: GenericResultItemFields<E>;
    isHighlighted?: boolean;
};
declare function DetailTextContentTwo<E>({ result, path, isHighlighted, }: DetailTextContentProps<E>): react_jsx_runtime.JSX.Element | null;

type DetailTitleProps = {
    children: React.ReactNode;
    fontSize?: string;
    fontweigth?: string;
    marginBottom?: string;
};
declare function DetailTitle({ children, fontSize, fontweigth, marginBottom, }: DetailTitleProps): react_jsx_runtime.JSX.Element;

type DownloadButtonProps = {
    location: string;
    filename: string;
    children: React.ReactNode;
};
declare function DownloadButton({ location, filename, children, }: DownloadButtonProps): react_jsx_runtime.JSX.Element;

type DocumentResultItem = {
    document: {
        title: string;
        relativeUrl: Array<string>;
        contentType: string;
        url: string;
        content: string;
        summary: string;
    };
};

declare function FileIcon({ result, }: {
    result: GenericResultItem<DocumentResultItem>;
}): react_jsx_runtime.JSX.Element;
declare const contentTypeSet: Set<unknown>;

type MoreDetailCars = {
    icon: React.ReactNode;
    date?: string;
};
declare function MoreDetailCard({ icon, date }: MoreDetailCars): react_jsx_runtime.JSX.Element;

type HighlightableTextProps<E> = {
    result: GenericResultItem<E>;
    path: GenericResultItemFields<E>;
};
declare function HighlightableText<E>({ result, path, }: HighlightableTextProps<E>): react_jsx_runtime.JSX.Element;

declare function HighlightedText({ text, Highlight, }: {
    text: string;
    Highlight?: React.FC<{
        children: React.ReactNode;
    }>;
}): react_jsx_runtime.JSX.Element;

type ResultAttributeProps = {
    label: string;
    children: React.ReactNode;
};
declare function ResultAttribute({ label, children }: ResultAttributeProps): react_jsx_runtime.JSX.Element;

type ResultContainerProps = {
    icon?: React.ReactNode;
    children: React.ReactNode;
};
declare function ResultContainer({ icon, children }: ResultContainerProps): react_jsx_runtime.JSX.Element;

type ResultFaviconProps = {
    src: string;
    maxHei?: string;
    maxWid?: string;
};
declare function ResultFavicon({ src, maxHei, maxWid, }: ResultFaviconProps): react_jsx_runtime.JSX.Element;

type ResultLinkProps$1 = {
    href: string;
    children: React.ReactNode;
};
declare function ResultLink({ href, children }: ResultLinkProps$1): react_jsx_runtime.JSX.Element;

declare function ResultTextContent<E>({ result, path, isTruncate, }: HighlightableTextProps<E> & {
    isTruncate?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ResultTextContentTwo<E>({ result, path, isTruncate, }: HighlightableTextProps<E> & {
    isTruncate?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ResultTextContentThree<E>({ result, path, isTruncate, }: HighlightableTextProps<E> & {
    isTruncate?: boolean;
}): react_jsx_runtime.JSX.Element;

type ResultTitleProps$1 = {
    children: React.ReactNode;
};
declare function ResultTitle({ children }: ResultTitleProps$1): react_jsx_runtime.JSX.Element;

type ResultTitleProps = {
    children: React.ReactNode;
    isTruncate?: boolean;
};
declare function ResultTitleTwo({ children, isTruncate, }: ResultTitleProps): react_jsx_runtime.JSX.Element;

type ImagesViewerProps = {
    images: Array<string>;
    showPagination: boolean;
};
declare function ImagesViewer({ images, showPagination }: ImagesViewerProps): react_jsx_runtime.JSX.Element;

declare const truncatedLineStyle: styled_components.RuleSet<object>;

type ResultLinkProps = {
    href: string;
    children: React.ReactNode;
    title?: string;
};
declare function ResultLinkTwo({ href, title, children, }: ResultLinkProps): react_jsx_runtime.JSX.Element;

declare function SanitizeHtml<E>({ result, path, isTruncate, }: HighlightableTextProps<E> & {
    isTruncate?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function SortResultList({ setSortResult, background, minHeight, color, }: {
    setSortResult: (sortResultNew: SortField) => void;
    background?: string;
    minHeight?: string;
    color?: string;
}): react_jsx_runtime.JSX.Element;

interface WrapperContainerProps {
    children: React.ReactNode;
    gap?: string;
}
declare function WrapperContainer({ children, gap, }: WrapperContainerProps): react_jsx_runtime.JSX.Element;

type DetailTitleExternalLinkProps = {
    href: string;
    children: React.ReactNode;
};
declare function DetailTitleExternalLink({ href, children, }: DetailTitleExternalLinkProps): react_jsx_runtime.JSX.Element;

type ResultTitleExternalLinkProps = {
    href: string;
    children: React.ReactNode;
};
declare function ResultTitleExternalLink({ href, children, }: ResultTitleExternalLinkProps): react_jsx_runtime.JSX.Element;

declare function CustomFontAwesomeIcon({ result, }: {
    result: GenericResultItem;
}): react_jsx_runtime.JSX.Element;

declare const RendererComponents_Badge: typeof Badge;
declare const RendererComponents_BadgeContainer: typeof BadgeContainer;
declare const RendererComponents_Chip: typeof Chip;
declare const RendererComponents_CustomFontAwesomeIcon: typeof CustomFontAwesomeIcon;
declare const RendererComponents_DateCard: typeof DateCard;
declare const RendererComponents_DetailAttribute: typeof DetailAttribute;
declare const RendererComponents_DetailContainer: typeof DetailContainer;
declare const RendererComponents_DetailFavicon: typeof DetailFavicon;
declare const RendererComponents_DetailHeaderImage: typeof DetailHeaderImage;
declare const RendererComponents_DetailIconContainer: typeof DetailIconContainer;
declare const RendererComponents_DetailLink: typeof DetailLink;
declare const RendererComponents_DetailTextContent: typeof DetailTextContent;
declare const RendererComponents_DetailTextContentTwo: typeof DetailTextContentTwo;
declare const RendererComponents_DetailTitle: typeof DetailTitle;
declare const RendererComponents_DetailTitleExternalLink: typeof DetailTitleExternalLink;
declare const RendererComponents_DownloadButton: typeof DownloadButton;
declare const RendererComponents_FileIcon: typeof FileIcon;
declare const RendererComponents_HighlightableText: typeof HighlightableText;
type RendererComponents_HighlightableTextProps<E> = HighlightableTextProps<E>;
declare const RendererComponents_HighlightedText: typeof HighlightedText;
declare const RendererComponents_ImagesViewer: typeof ImagesViewer;
declare const RendererComponents_MoreDetailCard: typeof MoreDetailCard;
declare const RendererComponents_ResultAttribute: typeof ResultAttribute;
declare const RendererComponents_ResultContainer: typeof ResultContainer;
declare const RendererComponents_ResultFavicon: typeof ResultFavicon;
declare const RendererComponents_ResultLink: typeof ResultLink;
declare const RendererComponents_ResultLinkTwo: typeof ResultLinkTwo;
declare const RendererComponents_ResultTextContent: typeof ResultTextContent;
declare const RendererComponents_ResultTextContentThree: typeof ResultTextContentThree;
declare const RendererComponents_ResultTextContentTwo: typeof ResultTextContentTwo;
declare const RendererComponents_ResultTitle: typeof ResultTitle;
declare const RendererComponents_ResultTitleExternalLink: typeof ResultTitleExternalLink;
declare const RendererComponents_ResultTitleTwo: typeof ResultTitleTwo;
declare const RendererComponents_SanitizeHtml: typeof SanitizeHtml;
declare const RendererComponents_SortResultList: typeof SortResultList;
declare const RendererComponents_WrapperContainer: typeof WrapperContainer;
declare const RendererComponents_contentTypeSet: typeof contentTypeSet;
declare const RendererComponents_truncatedLineStyle: typeof truncatedLineStyle;
declare namespace RendererComponents {
  export { RendererComponents_Badge as Badge, RendererComponents_BadgeContainer as BadgeContainer, RendererComponents_Chip as Chip, RendererComponents_CustomFontAwesomeIcon as CustomFontAwesomeIcon, RendererComponents_DateCard as DateCard, RendererComponents_DetailAttribute as DetailAttribute, RendererComponents_DetailContainer as DetailContainer, RendererComponents_DetailFavicon as DetailFavicon, RendererComponents_DetailHeaderImage as DetailHeaderImage, RendererComponents_DetailIconContainer as DetailIconContainer, RendererComponents_DetailLink as DetailLink, RendererComponents_DetailTextContent as DetailTextContent, RendererComponents_DetailTextContentTwo as DetailTextContentTwo, RendererComponents_DetailTitle as DetailTitle, RendererComponents_DetailTitleExternalLink as DetailTitleExternalLink, RendererComponents_DownloadButton as DownloadButton, RendererComponents_FileIcon as FileIcon, RendererComponents_HighlightableText as HighlightableText, RendererComponents_HighlightedText as HighlightedText, RendererComponents_ImagesViewer as ImagesViewer, RendererComponents_MoreDetailCard as MoreDetailCard, RendererComponents_ResultAttribute as ResultAttribute, RendererComponents_ResultContainer as ResultContainer, RendererComponents_ResultFavicon as ResultFavicon, RendererComponents_ResultLink as ResultLink, RendererComponents_ResultLinkTwo as ResultLinkTwo, RendererComponents_ResultTextContent as ResultTextContent, RendererComponents_ResultTextContentThree as ResultTextContentThree, RendererComponents_ResultTextContentTwo as ResultTextContentTwo, RendererComponents_ResultTitle as ResultTitle, RendererComponents_ResultTitleExternalLink as ResultTitleExternalLink, RendererComponents_ResultTitleTwo as ResultTitleTwo, RendererComponents_SanitizeHtml as SanitizeHtml, RendererComponents_SortResultList as SortResultList, RendererComponents_WrapperContainer as WrapperContainer, RendererComponents_contentTypeSet as contentTypeSet, RendererComponents_truncatedLineStyle as truncatedLineStyle };
  export type { RendererComponents_HighlightableTextProps as HighlightableTextProps };
}

type QueryState = {
    defaultTokens: Array<SearchToken>;
    tabTokens: Array<SearchToken>;
    filterTokens: Array<SearchToken>;
    searchTokens: Array<SearchToken>;
    numberOfFilters: number;
    numberOfResults: number;
};

type ResultsDisplayMode = {
    type: "finite";
} | {
    type: "infinite";
} | {
    type: "virtual";
};

type Tab = {
    label: string;
    tokens: Array<SearchToken>;
    translationMap: {
        [key: string]: string;
    };
    sortings: Options$1;
};

type Field = {
    field: string;
    id: number;
    isDefault: boolean;
    type: string;
    label: string;
    translationMap: {
        "label.en_US"?: string;
        "label.es_ES"?: string;
        "label.it_IT"?: string;
    };
};
type Options = Field[];

type TypeFilter = "filters" | "sort" | "language" | "calendar";
type TypeAllFilters = {
    filter: TypeFilter;
    sort: number;
}[] | null | undefined;

declare const rendererComponents: typeof RendererComponents;
declare class OpenK9 {
    static dependencies: {
        React: typeof React;
        ReactDOM: typeof ReactDOM;
        RestApi: typeof RestApi;
        SearchFrontend: {
            OpenK9: typeof OpenK9;
            rendererComponents: typeof RendererComponents;
        };
    };
    private configuration;
    /**
     * rest client instance used by this ui
     * @see {@link OpenK9Client} from **@openk9/rest-api** package
     */
    readonly client: {
        authInit: Promise<boolean> | null;
        authenticate({ token }: {
            token?: string;
        }): Promise<void>;
        deauthenticate(): Promise<void>;
        getUserProfile(): Promise<{}>;
        getGenerateResponse({ searchQuery, controller, }: {
            searchQuery: GenerateRequest;
            controller: AbortController;
        }): Promise<Response>;
        getServiceStatus(): Promise<"up" | "down">;
        doSearch<E>(searchRequest: {
            searchQuery: Array<SearchToken>;
            range: [number, number];
            sort: SortField[];
            language: string;
            sortAfterKey: string;
            overrideSearchWithCorrection?: boolean;
        }): Promise<{
            result: GenericResultItem<E>[];
            total: number;
            autocorrection: AutocorrectionType;
        }>;
        generateResponse<E>(searchRequest: GenerateRequest): Promise<any>;
        getDateFilterFields(): Promise<{
            id: number;
            field: string;
            label: string;
        }[]>;
        getLabelSort(): Promise<{
            field: string;
            id: number;
            label: string;
        }[]>;
        getLanguages(): Promise<{
            createDate: any;
            modifiedDate: any;
            id: number;
            name: string;
            value: "value";
        }[]>;
        getSortingInfo(): Promise<{
            field: string;
            id: number;
            isDefault: boolean;
            type: string;
            label: string;
            translationMap: {
                "label.en_US"?: string;
                "label.es_ES"?: string;
                "label.it_IT"?: string;
            };
        }[]>;
        getRefreshFilters(): Promise<{
            retrieveType: string;
            refreshOnSuggestionCategory: boolean;
            refreshOnTab: boolean;
            refreshOnDate: boolean;
            refreshOnQuery: boolean;
        }>;
        getLanguageDefault(): Promise<{
            value: string;
        }>;
        getSuggestions({ searchQuery, suggestionCategoryId, range, afterKey, suggestKeyword, order, language, }: {
            searchQuery: SearchToken[];
            suggestionCategoryId?: number;
            range?: [number, number];
            afterKey?: string;
            suggestKeyword?: string;
            order: "desc" | "asc";
            language: string;
        }): Promise<{
            result: SuggestionResult[];
            afterKey: string;
        }>;
        getAutocompletes({ searchText, }: {
            searchText: string;
        }): Promise<AutocompleteResponse>;
        handle_dynamic_filters(): Promise<{
            handleDynamicFilters: boolean;
        }>;
        getSuggestionCategories(): Promise<{
            name: string;
            id: number;
            multiSelect: boolean;
            translationMap: {
                [key: string]: string;
            };
        }[]>;
        getTabsByVirtualHost(): Promise<Array<{
            label: string;
            tokens: Array<SearchToken>;
            translationMap: {
                [key: string]: string;
            };
            sortings: Options$1;
        }>>;
        getTemplatesByVirtualHost(): Promise<Array<string>>;
        loadTemplate<E>(id: string): Promise<Template<E> | null>;
        fetchQueryAnalysis(request: AnalysisRequest): Promise<AnalysisResponse | null>;
    };
    private root;
    private queryClient;
    constructor(configuration?: Partial<Configuration>);
    /** returns current configuration */
    getConfiguration(): {
        autocompleteEnabled: boolean;
        autoselectTab?: boolean | null | undefined;
        debounceTimeSearch: number | null | undefined;
        defaultTokens: Array<SearchToken>;
        externalSearchTokens?: ExternalSearchTokens;
        defaultString: string | null | undefined;
        extraClass?: ExtraClassProps | null | undefined;
        languageSelect: string | null | undefined;
        enabled: boolean;
        callbackClient(): void | null | undefined;
        filterTokens: Array<SearchToken>;
        icons: IconsCustom;
        isQueryAnalysis: boolean | null;
        isActiveSkeleton: {
            results?: boolean | null;
            filters?: boolean | null;
            tabs?: boolean | null;
        } | null;
        filtersMobileBasicCallback: () => void | null | undefined;
        mobileFiltersBasicLiveChange: {
            closeFiltersMobileLiveChangeCallback?: () => void | null | undefined;
            applyfiltersMobileLiveChangeCallback?: () => void | null | undefined;
            viewTabs?: boolean | null | undefined;
            addExtraClass?: string | null | undefined;
        } | null | undefined;
        numberResult: number | null | undefined;
        numberResultOfFilters: number | null | undefined;
        memoryResults: boolean | null | undefined;
        searchAutoselect: boolean;
        searchReplaceText: boolean;
        skeletonTabsCustom: React.ReactNode | null;
        skeletonResultsCustom: React.ReactNode | null;
        skeletonFiltersCustom: React.ReactNode | null;
        skeletonSuggestionCustom: React.ReactNode | null;
        sort: Array<SortField>;
        showSyntax: boolean;
        styledSkeletonResults: {
            background?: string | undefined | null;
        } | null | undefined;
        tenant: string | null;
        token: string | null;
        useQueryAnalysis: boolean;
        useKeycloak: boolean;
        useGenerativeApi: boolean | null | undefined;
        useQueryString: boolean;
        useQueryStringFilters: boolean;
        useFilterConfiguration: boolean;
        viewButton: boolean;
        waitKeycloackForToken: boolean;
        activeFilters: Element | string | null;
        calendar: Element | string | null;
        calendarVertical: Element | string | null;
        changeLanguage: Element | string | null;
        detailMobile: Element | string | null;
        details: Element | string | null;
        filters: Element | string | null;
        filtersMobileBasic: Element | string | null;
        generateResponse: Element | string | null;
        login: Element | string | null;
        queryStringValues: queryStringValues;
        queryStringMap: queryStringMapType;
        results: Element | string | null;
        search: Element | string | null;
        searchWithButton: Element | string | null;
        sortable: Element | string | null;
        tabs: Element | string | null;
        totalResult: Element | string | null;
        totalResultMobile: Element | string | null;
        removeFilters: Element | string | null;
        activeFiltersConfigurable: activeFiltersConfigurableProps | null | undefined;
        allFilters: allFiltersConfigurableProps | undefined | null;
        calendarMobile: CalendarMobileConfiguration | null;
        correction: correctionType | undefined | null;
        dataRangePicker: DataRangePickerProps | null;
        dataRangePickerVertical: DataRangePickerVerticalProps | null;
        filtersConfigurable: FilterProps | null;
        filtersHorizontal: FiltersHorizontalConfiguration | null;
        filtersMobile: FiltersHorizontalMobileConfiguration | null;
        filtersMobileLiveChange: FiltersLiveMobileConfiguration | null;
        filtersMobileLiveChangeBasic: Element | string | null;
        removeFiltersConfigurable: RemoveFiltersProps | null;
        resultList: ResultListProps | null;
        resultListPagination: ResulListPaginationProps | null;
        resultsDisplayMode: ResultsDisplayMode;
        searchConfigurable: SearchProps | null;
        searchWithSuggestions: searchWithSuggestionsProps;
        searchMobile: SearchMobileConfiguration | null;
        select: SelectProps | null;
        skeleton: SkeletonProps | null;
        sortableConfigurable: SortableProps | null;
        sortResults: SortResultsProps | null;
        sortResultConfigurable: SortResultConfigurableProps | null;
        sortResultListCustom: SortResultListCustomProps | null;
        tabsConfigurable: TabsProps | null;
        template: TemplatesProps | null;
        totalResultConfigurable: totalResultProps | null;
        changeSortResult: (sort: Array<SortField>) => Array<SortField>;
        overrideTabs: (tabs: Array<Tab>) => Array<Tab>;
    };
    /**
     * updates configuration with provided fields
     *
     * also accepts a function that produces an object with fields to update
     */
    updateConfiguration: ConfigurationUpdateFunction;
    private render;
    private getRootElement;
    /** authenticate the user with given token */
    authenticate: ({ token }: {
        token?: string;
    }) => Promise<void>;
    /** logs out the user, all subsequent queries will be anonymous */
    deauthenticate: () => Promise<void>;
    private listeners;
    private notify;
    addEventListener<E extends keyof Events>(event: E, listener: (payload: Events[E]) => void): void;
    removeEventListener<E extends keyof Events>(event: E, listener: (payload: Events[E]) => void): void;
    private onQueryStateChange;
}
type FiltersHorizontalConfiguration = {
    element: Element | string | null;
    callback: () => void | null;
    callbackSubmit: () => void | null;
    callbackReset: () => void | null;
    refButton?: React.RefObject<HTMLButtonElement>;
};
type FiltersHorizontalMobileConfiguration = {
    element: Element | string | null;
    isVisible: boolean;
    setIsVisible: React.Dispatch<React.SetStateAction<boolean>>;
};
type FiltersLiveMobileConfiguration = {
    element: Element | string | null;
    isVisible: boolean;
    setIsVisible: React.Dispatch<React.SetStateAction<boolean>>;
    viewTabs?: boolean | null;
    isCollapsable?: boolean | null;
    haveSearch?: boolean | null;
};
type SearchMobileConfiguration = {
    search: Element | string | null;
    isVisible: boolean;
    setIsVisible: React.Dispatch<React.SetStateAction<boolean>>;
    isShowSyntax?: boolean | undefined | null;
};
type CalendarMobileConfiguration = {
    element: Element | string | null;
    isVisible: boolean;
    setIsVisible: React.Dispatch<React.SetStateAction<boolean>>;
    startDate: any;
    setStartDate: any;
    endDate: any;
    setEndDate: any;
    focusedInput: any;
    setFocusedInput: any;
    isCLickReset: boolean;
    setIsCLickReset: React.Dispatch<React.SetStateAction<boolean>>;
};
type DataRangePickerProps = {
    element: Element | string | null;
    start?: any;
    end?: any;
};
type DataRangePickerVerticalProps = {
    element: Element | string | null;
    start?: any;
    end?: any;
    readOnly?: boolean;
    internationalLabel?: {
        labelStart?: string;
        labelEnd?: string;
        placeholderStart?: string;
        placeholderEnd?: string;
        errorFormatData?: string;
        errorSelectData?: string;
    };
};
type ResultListProps = {
    element: Element | string | null;
    changeOnOver: boolean;
    counterIsVisible?: boolean;
    label?: string;
    noResultsCustom?: React.ReactNode;
};
type SortResultConfigurableProps = {
    sort: Element | string | null;
    relevance: string;
    htmlKey?: string | null | undefined;
};
type SortResultListCustomProps = {
    selectOptions: Array<{
        value: {
            value: string;
            sort: string;
        };
        label: string;
        sort: string;
        isDefault: boolean;
        hasAscDesc: boolean;
    }>;
    labelSort?: string | null | undefined;
    element: Element | string | null;
};
type SortableProps = {
    element: Element | string | null;
    relevance: string;
};
type characterControlType = {
    actionCharacter(): void;
    numberOfCharacters: number;
};
type SearchProps = {
    element: Element | string | null;
    btnSearch: boolean;
    defaultValue?: string | undefined | null;
    htmlKey?: string | undefined | null;
    messageSearchIsVisible?: boolean;
    customMessageSearch?: string;
    characterControl?: characterControlType;
    actionOnClick?(): void;
    callbackClickSearch?(): void;
    callbackChangeSearch?(text: string): void;
};
type FilterProps = {
    element: Element | string | null;
    numberItems?: number | null | undefined;
    noResultMessage?: string | null | undefined;
    placeholder?: string | null | undefined;
    haveSearch?: boolean | null | undefined;
};
type ResulListPaginationProps = {
    element: Element | string | null;
    callback?: () => void | null | undefined;
    noResultsCustom?: React.ReactNode | null | undefined;
};
type ExternalSearchTokenKind = "tabs" | "search" | "filters";
type ExternalSearchTokenEntry = {
    kind: ExternalSearchTokenKind;
    tokens: Array<SearchToken>;
};
type ExternalSearchTokens = Array<ExternalSearchTokenEntry> | null | undefined;
type TabsCallbackProps = ({ callbackSelectTab, callbackUnselectTab, tabs, selectedTabIndex, }: {
    callbackSelectTab: (tabSelect: {
        index: number;
    }) => void;
    callbackUnselectTab: (index: number) => void;
    tabs: Tab[];
    selectedTabIndex: number;
}) => React.ReactNode;
type TabsProps = {
    element: Element | string | null;
    onAction?(): void;
    scrollMode?: boolean;
    speed?: number;
    distance?: number;
    step?: number;
    pxHiddenRightArrow?: number;
    reset?: {
        filters: boolean;
        calendar: boolean;
        sort: boolean;
        search: boolean;
    };
    readMessageScreenReader?: boolean;
    textLabelScreenReader?: string;
    tabs?: TabsCallbackProps;
    isUnselectTab: boolean;
};
type SelectProps = {
    element: Element | string | null;
    options: Options;
    extraClass?: string;
    handleChange: (event: React.ChangeEvent<HTMLSelectElement>) => void;
};
type SortResultsProps = {
    element: Element | string | null;
    extraClass?: string;
    classNameLabel?: string | undefined;
    labelText?: string | undefined;
    defaultLabelName?: string | undefined;
};
type totalResultProps = {
    element: Element | string | null;
    saveTotalResultState?: React.Dispatch<React.SetStateAction<number | null>>;
};
type activeFiltersConfigurableProps = {
    element: Element | string | null;
    actioneRemoveFilters?(): void;
    callbackRemoveFilter?(): void;
};
type SkeletonProps = {
    skeleton: Element | string | null;
    width?: string | null | undefined;
    height?: string | null | undefined;
    counter?: number | null | undefined;
    circle?: boolean | null | undefined;
    backgroundColor?: string | null | undefined;
    itereitorKey?: string | null | undefined;
    containerMax?: boolean | null | undefined;
    position?: "column" | "row";
    gap?: string | null | undefined;
};
type searchWithSuggestionsProps = {
    element: Element | string | null;
    callbackSearchButton?(): void;
    ariaLabelIcon?: string;
    placeholder?: string;
} | null | undefined;
type RemoveFiltersProps = {
    element: Element | string | null;
    itemsRemove?: resetFiltersType;
    label?: string | null | undefined;
    ariaLabel?: string | null | undefined;
    callback?: () => void;
};
type resetFiltersType = Array<"filters" | "calendar" | "sort" | "search" | "language">;
type TemplatesProps = Array<{
    source: string;
    Template: React.FC<any>;
    TemplateDetail: React.FC<any>;
}>;
type ExtraClassProps = {
    classSearch?: {
        input?: string;
        button?: string;
    } | null | undefined;
    classResultsListPagination?: {
        buttonPagination?: string;
        activeButtonPagination?: string;
    } | null | undefined;
};
type IconsCustom = {
    Search?: React.ReactNode;
} | null | undefined;
type queryStringMapType = ({
    keyObj?: string | null | undefined;
} & Partial<{
    text: string;
    textOnChange: string;
    filters: string;
    selection: string;
}>) | null | undefined;
type correctionType = {
    element: Element | string | null;
    information: (correctedQuery: string, errorQuery: string, confirm: () => void, hasAutocorretion?: boolean, confirmedErrorQuery?: () => void) => React.ReactNode;
};
type translationGlobalType = {
    labelStart?: string;
    labelEnd?: string;
    placeholderStart?: string;
    placeholderEnd?: string;
    errorFormatData?: string;
    errorSelectData?: string;
    filtersLabel?: string;
    calendarLabel?: string;
    buttonResetFilters?: string;
    buttonSaveFilters?: string;
    ariaLabelSave?: string;
    ariaLabelReset?: string;
    labelContainerDateTitleStart?: string;
    labelContainerDateTitleEnd?: string;
};
type allFiltersConfigurableProps = {
    element: Element | string | null;
    typeFilters: TypeAllFilters;
    translationLabel?: translationGlobalType;
    callbackSave?(): void | null | undefined;
    callbackReset?(): void | null | undefined;
};
type Configuration = {
    autocompleteEnabled: boolean;
    autoselectTab?: boolean | null | undefined;
    debounceTimeSearch: number | null | undefined;
    defaultTokens: Array<SearchToken>;
    externalSearchTokens?: ExternalSearchTokens;
    defaultString: string | null | undefined;
    extraClass?: ExtraClassProps | null | undefined;
    languageSelect: string | null | undefined;
    enabled: boolean;
    callbackClient(): void | null | undefined;
    filterTokens: Array<SearchToken>;
    icons: IconsCustom;
    isQueryAnalysis: boolean | null;
    isActiveSkeleton: {
        results?: boolean | null;
        filters?: boolean | null;
        tabs?: boolean | null;
    } | null;
    filtersMobileBasicCallback: () => void | null | undefined;
    mobileFiltersBasicLiveChange: {
        closeFiltersMobileLiveChangeCallback?: () => void | null | undefined;
        applyfiltersMobileLiveChangeCallback?: () => void | null | undefined;
        viewTabs?: boolean | null | undefined;
        addExtraClass?: string | null | undefined;
    } | null | undefined;
    numberResult: number | null | undefined;
    numberResultOfFilters: number | null | undefined;
    memoryResults: boolean | null | undefined;
    searchAutoselect: boolean;
    searchReplaceText: boolean;
    skeletonTabsCustom: React.ReactNode | null;
    skeletonResultsCustom: React.ReactNode | null;
    skeletonFiltersCustom: React.ReactNode | null;
    skeletonSuggestionCustom: React.ReactNode | null;
    sort: Array<SortField>;
    showSyntax: boolean;
    styledSkeletonResults: {
        background?: string | undefined | null;
    } | null | undefined;
    tenant: string | null;
    token: string | null;
    useQueryAnalysis: boolean;
    useKeycloak: boolean;
    useGenerativeApi: boolean | null | undefined;
    useQueryString: boolean;
    useQueryStringFilters: boolean;
    useFilterConfiguration: boolean;
    viewButton: boolean;
    waitKeycloackForToken: boolean;
    activeFilters: Element | string | null;
    calendar: Element | string | null;
    calendarVertical: Element | string | null;
    changeLanguage: Element | string | null;
    detailMobile: Element | string | null;
    details: Element | string | null;
    filters: Element | string | null;
    filtersMobileBasic: Element | string | null;
    generateResponse: Element | string | null;
    login: Element | string | null;
    queryStringValues: queryStringValues;
    queryStringMap: queryStringMapType;
    results: Element | string | null;
    search: Element | string | null;
    searchWithButton: Element | string | null;
    sortable: Element | string | null;
    tabs: Element | string | null;
    totalResult: Element | string | null;
    totalResultMobile: Element | string | null;
    removeFilters: Element | string | null;
    activeFiltersConfigurable: activeFiltersConfigurableProps | null | undefined;
    allFilters: allFiltersConfigurableProps | undefined | null;
    calendarMobile: CalendarMobileConfiguration | null;
    correction: correctionType | undefined | null;
    dataRangePicker: DataRangePickerProps | null;
    dataRangePickerVertical: DataRangePickerVerticalProps | null;
    filtersConfigurable: FilterProps | null;
    filtersHorizontal: FiltersHorizontalConfiguration | null;
    filtersMobile: FiltersHorizontalMobileConfiguration | null;
    filtersMobileLiveChange: FiltersLiveMobileConfiguration | null;
    filtersMobileLiveChangeBasic: Element | string | null;
    removeFiltersConfigurable: RemoveFiltersProps | null;
    resultList: ResultListProps | null;
    resultListPagination: ResulListPaginationProps | null;
    resultsDisplayMode: ResultsDisplayMode;
    searchConfigurable: SearchProps | null;
    searchWithSuggestions: searchWithSuggestionsProps;
    searchMobile: SearchMobileConfiguration | null;
    select: SelectProps | null;
    skeleton: SkeletonProps | null;
    sortableConfigurable: SortableProps | null;
    sortResults: SortResultsProps | null;
    sortResultConfigurable: SortResultConfigurableProps | null;
    sortResultListCustom: SortResultListCustomProps | null;
    tabsConfigurable: TabsProps | null;
    template: TemplatesProps | null;
    totalResultConfigurable: totalResultProps | null;
    changeSortResult: (sort: Array<SortField>) => Array<SortField>;
    overrideTabs: (tabs: Array<Tab>) => Array<Tab>;
};
type ConfigurationUpdateFunction = (configuration: Partial<Configuration> | ((configuration: Configuration) => Partial<Configuration>)) => void;
type Events = {
    configurationChange: Configuration;
    queryStateChange: QueryState;
};
declare global {
    interface Window {
        OpenK9: typeof OpenK9;
    }
}
type queryStringValues = ("text" | "selection" | "textOnChange" | "filters")[] | null | undefined;

export { OpenK9, rendererComponents };
export type { Configuration, ConfigurationUpdateFunction, ExternalSearchTokenEntry, ExternalSearchTokenKind, ExternalSearchTokens, ExtraClassProps, IconsCustom, TabsCallbackProps, TemplatesProps, characterControlType, queryStringMapType, queryStringValues, resetFiltersType, translationGlobalType };
