import { PropType } from 'vue';
import { TablePaginationSizeOption } from '../../types';
declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    paginationSizeOptions: {
        type: PropType<TablePaginationSizeOption[]>;
        required: true;
    };
    itemsPerPage: {
        type: NumberConstructor;
        required: true;
    };
    nextDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    prevDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    lastDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    defaultItemsPerPageLabel: import("vue").ComputedRef<string>;
    currentItemsPerPageLabel: import("vue").ComputedRef<string>;
    btnLabelFirst: import("vue").ComputedRef<string>;
    btnLabelNext: import("vue").ComputedRef<string>;
    btnLabelPrev: import("vue").ComputedRef<string>;
    btnLabelLast: import("vue").ComputedRef<string>;
    wrappedItemsPerPage: import("vue").WritableComputedRef<number, number>;
    cdxIconPrevious: import("@wikimedia/codex-icons").IconFlipForRtl;
    cdxIconNext: import("@wikimedia/codex-icons").IconFlipForRtl;
    cdxIconMoveFirst: import("@wikimedia/codex-icons").IconFlipForRtl;
    cdxIconMoveLast: import("@wikimedia/codex-icons").IconFlipForRtl;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("first" | "last" | "next" | "update:itemsPerPage" | "prev")[], "first" | "last" | "next" | "update:itemsPerPage" | "prev", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    paginationSizeOptions: {
        type: PropType<TablePaginationSizeOption[]>;
        required: true;
    };
    itemsPerPage: {
        type: NumberConstructor;
        required: true;
    };
    nextDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    prevDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    lastDisabled: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onFirst?: ((...args: any[]) => any) | undefined;
    onLast?: ((...args: any[]) => any) | undefined;
    onNext?: ((...args: any[]) => any) | undefined;
    "onUpdate:itemsPerPage"?: ((...args: any[]) => any) | undefined;
    onPrev?: ((...args: any[]) => any) | undefined;
}>, {
    nextDisabled: boolean;
    prevDisabled: boolean;
    lastDisabled: boolean;
}, {}, {
    CdxButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        action: {
            type: PropType<import("../../types").ButtonAction>;
            default: string;
            validator: import("../../types").StringTypeValidator<"default" | "progressive" | "destructive">;
        };
        weight: {
            type: PropType<import("../../types").ButtonWeight>;
            default: string;
            validator: import("../../types").StringTypeValidator<"normal" | "primary" | "quiet">;
        };
        size: {
            type: PropType<import("../../types").ButtonSize>;
            default: string;
            validator: import("../../types").StringTypeValidator<"medium" | "large" | "small">;
        };
    }>, {
        button: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
        rootClasses: import("vue").ComputedRef<{
            [x: string]: boolean;
            'cdx-button--framed': boolean;
            'cdx-button--icon-only': boolean;
            'cdx-button--is-active': boolean;
        }>;
        onClick: (event: Event) => void;
        onKeyDown: () => void;
        onKeyUp: () => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        action: {
            type: PropType<import("../../types").ButtonAction>;
            default: string;
            validator: import("../../types").StringTypeValidator<"default" | "progressive" | "destructive">;
        };
        weight: {
            type: PropType<import("../../types").ButtonWeight>;
            default: string;
            validator: import("../../types").StringTypeValidator<"normal" | "primary" | "quiet">;
        };
        size: {
            type: PropType<import("../../types").ButtonSize>;
            default: string;
            validator: import("../../types").StringTypeValidator<"medium" | "large" | "small">;
        };
    }>> & Readonly<{
        onClick?: ((...args: any[]) => any) | undefined;
    }>, {
        size: "medium" | "large" | "small";
        action: "default" | "progressive" | "destructive";
        weight: "normal" | "primary" | "quiet";
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        icon: {
            type: PropType<import("@wikimedia/codex-icons").Icon>;
            required: true;
        };
        iconLabel: {
            type: StringConstructor;
            default: string;
        };
        lang: {
            type: PropType<string | null>;
            default: null;
        };
        dir: {
            type: PropType<import("../../types").HTMLDirection | null>;
            default: null;
        };
        size: {
            type: PropType<import("../../types").IconSize>;
            default: string;
            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
        };
    }>, {
        rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
        rootClasses: import("vue").ComputedRef<{
            [x: string]: boolean;
            'cdx-icon--flipped': boolean;
        }>;
        iconSvg: import("vue").ComputedRef<string>;
        iconPath: import("vue").ComputedRef<string>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        icon: {
            type: PropType<import("@wikimedia/codex-icons").Icon>;
            required: true;
        };
        iconLabel: {
            type: StringConstructor;
            default: string;
        };
        lang: {
            type: PropType<string | null>;
            default: null;
        };
        dir: {
            type: PropType<import("../../types").HTMLDirection | null>;
            default: null;
        };
        size: {
            type: PropType<import("../../types").IconSize>;
            default: string;
            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
        };
    }>> & Readonly<{}>, {
        lang: string | null;
        iconLabel: string;
        dir: import("../../types").HTMLDirection | null;
        size: "medium" | "small" | "x-small";
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    CdxSelect: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        menuItems: {
            type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
            required: true;
        };
        selected: {
            type: PropType<string | number | null>;
            required: true;
        };
        defaultLabel: {
            type: StringConstructor;
            default: string;
        };
        name: {
            type: StringConstructor;
            default: undefined;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        menuConfig: {
            type: PropType<import("../../types").MenuConfig>;
            default: () => import("../../types").MenuConfig;
        };
        defaultIcon: {
            type: PropType<import("@wikimedia/codex-icons").Icon>;
            default: undefined;
        };
        status: {
            type: PropType<import("../../types").ValidationStatusType>;
            default: string;
            validator: import("../../types").StringTypeValidator<"default" | "warning" | "error" | "success">;
        };
    }>, {
        handle: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
        menu: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            menuItems: {
                type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
                required: true;
            };
            footer: {
                type: PropType<import("../../types").MenuItemData>;
                default: null;
            };
            selected: {
                type: PropType<import("../../types").MenuItemValue | import("../../types").MenuItemValue[] | null>;
                required: true;
            };
            expanded: {
                type: BooleanConstructor;
                required: true;
            };
            showPending: {
                type: BooleanConstructor;
                default: boolean;
            };
            visibleItemLimit: {
                type: PropType<number | null>;
                default: null;
            };
            showThumbnail: {
                type: BooleanConstructor;
                default: boolean;
            };
            boldLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideDescriptionOverflow: {
                type: BooleanConstructor;
                default: boolean;
            };
            searchQuery: {
                type: StringConstructor;
                default: string;
            };
            showNoResultsSlot: {
                type: PropType<boolean | null>;
                default: null;
            };
            renderInPlace: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            "onUpdate:selected"?: ((...args: any[]) => any) | undefined;
            "onUpdate:expanded"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-click"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-keyboard-navigation"?: ((...args: any[]) => any) | undefined;
            "onLoad-more"?: ((...args: any[]) => any) | undefined;
        }>, {
            listBoxStyle: import("vue").ComputedRef<{
                'max-height': string | undefined;
                'margin-bottom': string | undefined;
            }>;
            rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
            rootStyle: import("vue").ComputedRef<import("vue").StyleValue>;
            otherAttrs: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            assignTemplateRef: (templateRef: import("vue").ComponentPublicInstance | Element | null, index: number) => void;
            computedMenuEntries: import("vue").ComputedRef<(import("../../types").MenuItemDataWithId | import("../../types").MenuGroupDataWithIds)[]>;
            computedMenuItems: import("vue").ComputedRef<import("../../types").MenuItemDataWithId[]>;
            computedShowNoResultsSlot: import("vue").ComputedRef<boolean>;
            highlightedMenuItem: import("vue").Ref<{
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null, import("../../types").MenuItemDataWithId | {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null>;
            highlightedViaKeyboard: import("vue").Ref<boolean, boolean>;
            teleportDisabled: import("vue").ComputedRef<boolean>;
            computedTarget: import("vue").ComputedRef<string | HTMLElement>;
            handleMenuItemChange: (menuState: import("../../types").MenuState, menuItem: import("../../types").MenuItemDataWithId | null) => void;
            handleKeyNavigation: (e: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }) => boolean;
            ariaRelevant: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
            isMultiselect: import("vue").ComputedRef<boolean>;
            rootElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            menuListbox: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            getGroupWrapperClasses: (group: import("../../types").MenuGroupData) => {
                'cdx-menu__group-wrapper--hide-label': boolean;
            };
            getMenuItemIndex: (menuItem: import("../../types").MenuItemDataWithId) => number;
            getMenuItemBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string;
                match?: string;
                supportingText?: string;
                description?: string | null;
                language?: import("../../types").MenuItemLanguageData;
                icon?: import("@wikimedia/codex-icons").Icon;
                thumbnail?: import("../../types").Thumbnail | null;
                url?: string;
                urlNewTab?: boolean;
                disabled?: boolean;
                selected: boolean;
                active: boolean;
                highlighted: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                searchQuery: string;
                multiselect: boolean;
            };
            getMenuItemHandlers: (menuItem: import("../../types").MenuItemDataWithId) => {
                change: (menuState: import("../../types").MenuState, setState: boolean) => void;
                click: () => void;
            };
            getSlotBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                menuItem: import("../../types").MenuItemDataWithId;
                active: boolean;
            };
            isMenuGroupData: (menuEntry: import("../../types").MenuItemData | import("../../types").MenuGroupData) => menuEntry is import("../../types").MenuGroupData;
        }, {}, {}, {
            isExpanded(): boolean;
            getRootElement(): HTMLElement | undefined;
            getHighlightedMenuItem(): import("../../types").MenuItemDataWithId | null;
            getHighlightedViaKeyboard(): boolean;
            getComputedMenuItems(): import("../../types").MenuItemDataWithId[];
            clearActive(): void;
            delegateKeyNavigation(event: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }): boolean;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:selected" | "update:expanded" | "menu-item-click" | "menu-item-keyboard-navigation" | "load-more")[], import("vue").PublicProps, {
            footer: import("../../types").MenuItemData;
            searchQuery: string;
            showThumbnail: boolean;
            boldLabel: boolean;
            hideDescriptionOverflow: boolean;
            showPending: boolean;
            visibleItemLimit: number | null;
            showNoResultsSlot: boolean | null;
            renderInPlace: boolean;
        }, true, {}, {}, {
            CdxMenuItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: PropType<import("../../types").MenuItemValue>;
                    required: true;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selected: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                active: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                highlighted: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                match: {
                    type: StringConstructor;
                    default: string;
                };
                supportingText: {
                    type: StringConstructor;
                    default: string;
                };
                url: {
                    type: StringConstructor;
                    default: string;
                };
                urlNewTab: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    default: string;
                };
                showThumbnail: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                thumbnail: {
                    type: PropType<import("../../types").Thumbnail | null>;
                    default: null;
                };
                description: {
                    type: PropType<string | null>;
                    default: string;
                };
                searchQuery: {
                    type: StringConstructor;
                    default: string;
                };
                boldLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideDescriptionOverflow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                language: {
                    type: PropType<import("../../types").MenuItemLanguageData>;
                    default: () => {};
                };
                action: {
                    type: PropType<import("../../types").ButtonAction>;
                    default: string;
                };
                multiselect: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                onMouseMove: () => void;
                onMouseLeave: () => void;
                onMouseDown: (e: MouseEvent) => void;
                onClick: () => void;
                highlightQuery: import("vue").ComputedRef<boolean>;
                rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
                contentTag: import("vue").ComputedRef<"span" | "a">;
                linkAttrs: import("vue").ComputedRef<{
                    target: string;
                    rel: string;
                } | {
                    target?: undefined;
                    rel?: undefined;
                }>;
                title: import("vue").ComputedRef<string>;
                cdxIconCheck: string;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: PropType<import("../../types").MenuItemValue>;
                    required: true;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selected: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                active: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                highlighted: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                match: {
                    type: StringConstructor;
                    default: string;
                };
                supportingText: {
                    type: StringConstructor;
                    default: string;
                };
                url: {
                    type: StringConstructor;
                    default: string;
                };
                urlNewTab: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    default: string;
                };
                showThumbnail: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                thumbnail: {
                    type: PropType<import("../../types").Thumbnail | null>;
                    default: null;
                };
                description: {
                    type: PropType<string | null>;
                    default: string;
                };
                searchQuery: {
                    type: StringConstructor;
                    default: string;
                };
                boldLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideDescriptionOverflow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                language: {
                    type: PropType<import("../../types").MenuItemLanguageData>;
                    default: () => {};
                };
                action: {
                    type: PropType<import("../../types").ButtonAction>;
                    default: string;
                };
                multiselect: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onChange?: ((...args: any[]) => any) | undefined;
            }>, {
                url: string;
                selected: boolean;
                highlighted: boolean;
                active: boolean;
                icon: import("@wikimedia/codex-icons").Icon;
                label: string;
                match: string;
                action: "default" | "progressive" | "destructive";
                disabled: boolean;
                thumbnail: import("../../types").Thumbnail | null;
                description: string | null;
                searchQuery: string;
                supportingText: string;
                urlNewTab: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                language: import("../../types").MenuItemLanguageData;
                multiselect: boolean;
            }, {}, {
                CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    icon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        required: true;
                    };
                    iconLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    lang: {
                        type: PropType<string | null>;
                        default: null;
                    };
                    dir: {
                        type: PropType<import("../../types").HTMLDirection | null>;
                        default: null;
                    };
                    size: {
                        type: PropType<import("../../types").IconSize>;
                        default: string;
                        validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                    };
                }>, {
                    rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                    rootClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'cdx-icon--flipped': boolean;
                    }>;
                    iconSvg: import("vue").ComputedRef<string>;
                    iconPath: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    icon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        required: true;
                    };
                    iconLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    lang: {
                        type: PropType<string | null>;
                        default: null;
                    };
                    dir: {
                        type: PropType<import("../../types").HTMLDirection | null>;
                        default: null;
                    };
                    size: {
                        type: PropType<import("../../types").IconSize>;
                        default: string;
                        validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                    };
                }>> & Readonly<{}>, {
                    lang: string | null;
                    iconLabel: string;
                    dir: import("../../types").HTMLDirection | null;
                    size: "medium" | "small" | "x-small";
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                CdxThumbnail: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    thumbnail: {
                        type: PropType<import("../../types").Thumbnail | null>;
                        default: null;
                    };
                    placeholderIcon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        default: string;
                    };
                }>, {
                    thumbnailStyle: import("vue").Ref<{}, {}>;
                    thumbnailLoaded: import("vue").Ref<boolean, boolean>;
                    NoInvertClass: "cdx-no-invert";
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    thumbnail: {
                        type: PropType<import("../../types").Thumbnail | null>;
                        default: null;
                    };
                    placeholderIcon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        default: string;
                    };
                }>> & Readonly<{}>, {
                    thumbnail: import("../../types").Thumbnail | null;
                    placeholderIcon: import("@wikimedia/codex-icons").Icon;
                }, {}, {
                    CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        icon: {
                            type: PropType<import("@wikimedia/codex-icons").Icon>;
                            required: true;
                        };
                        iconLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        lang: {
                            type: PropType<string | null>;
                            default: null;
                        };
                        dir: {
                            type: PropType<import("../../types").HTMLDirection | null>;
                            default: null;
                        };
                        size: {
                            type: PropType<import("../../types").IconSize>;
                            default: string;
                            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                        };
                    }>, {
                        rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                        rootClasses: import("vue").ComputedRef<{
                            [x: string]: boolean;
                            'cdx-icon--flipped': boolean;
                        }>;
                        iconSvg: import("vue").ComputedRef<string>;
                        iconPath: import("vue").ComputedRef<string>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        icon: {
                            type: PropType<import("@wikimedia/codex-icons").Icon>;
                            required: true;
                        };
                        iconLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        lang: {
                            type: PropType<string | null>;
                            default: null;
                        };
                        dir: {
                            type: PropType<import("../../types").HTMLDirection | null>;
                            default: null;
                        };
                        size: {
                            type: PropType<import("../../types").IconSize>;
                            default: string;
                            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                        };
                    }>> & Readonly<{}>, {
                        lang: string | null;
                        iconLabel: string;
                        dir: import("../../types").HTMLDirection | null;
                        size: "medium" | "small" | "x-small";
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                CdxSearchResultTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    title: {
                        type: StringConstructor;
                        required: true;
                    };
                    searchQuery: {
                        type: StringConstructor;
                        default: string;
                    };
                }>, {
                    titleChunks: import("vue").ComputedRef<[string, string, string]>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    title: {
                        type: StringConstructor;
                        required: true;
                    };
                    searchQuery: {
                        type: StringConstructor;
                        default: string;
                    };
                }>> & Readonly<{}>, {
                    searchQuery: string;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    required: true;
                };
                iconLabel: {
                    type: StringConstructor;
                    default: string;
                };
                lang: {
                    type: PropType<string | null>;
                    default: null;
                };
                dir: {
                    type: PropType<import("../../types").HTMLDirection | null>;
                    default: null;
                };
                size: {
                    type: PropType<import("../../types").IconSize>;
                    default: string;
                    validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                };
            }>, {
                rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                rootClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'cdx-icon--flipped': boolean;
                }>;
                iconSvg: import("vue").ComputedRef<string>;
                iconPath: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    required: true;
                };
                iconLabel: {
                    type: StringConstructor;
                    default: string;
                };
                lang: {
                    type: PropType<string | null>;
                    default: null;
                };
                dir: {
                    type: PropType<import("../../types").HTMLDirection | null>;
                    default: null;
                };
                size: {
                    type: PropType<import("../../types").IconSize>;
                    default: string;
                    validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                };
            }>> & Readonly<{}>, {
                lang: string | null;
                iconLabel: string;
                dir: import("../../types").HTMLDirection | null;
                size: "medium" | "small" | "x-small";
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            CdxProgressBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                value: {
                    type: (NumberConstructor | null)[];
                    default: null;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                inline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                startLabel: {
                    type: StringConstructor;
                    default: string;
                };
                endLabel: {
                    type: StringConstructor;
                    default: string;
                };
            }>, {
                rootClasses: import("vue").ComputedRef<{
                    'cdx-progress-bar--block': boolean;
                    'cdx-progress-bar--inline': boolean;
                    'cdx-progress-bar--enabled': boolean;
                    'cdx-progress-bar--disabled': boolean;
                }>;
                computedAriaHidden: import("vue").ComputedRef<"true" | undefined>;
                hasValue: import("vue").ComputedRef<boolean>;
                progressStyles: import("vue").ComputedRef<{
                    '--cdx-progress-value': number;
                    '--cdx-progress-max': number;
                }>;
                clampedValue: import("vue").ComputedRef<number>;
                labelsId: string;
                ariaLabelledBy: import("vue").ComputedRef<string | undefined>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                value: {
                    type: (NumberConstructor | null)[];
                    default: null;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                inline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                startLabel: {
                    type: StringConstructor;
                    default: string;
                };
                endLabel: {
                    type: StringConstructor;
                    default: string;
                };
            }>> & Readonly<{}>, {
                disabled: boolean;
                value: number | null;
                inline: boolean;
                max: number;
                startLabel: string;
                endLabel: string;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            menuItems: {
                type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
                required: true;
            };
            footer: {
                type: PropType<import("../../types").MenuItemData>;
                default: null;
            };
            selected: {
                type: PropType<import("../../types").MenuItemValue | import("../../types").MenuItemValue[] | null>;
                required: true;
            };
            expanded: {
                type: BooleanConstructor;
                required: true;
            };
            showPending: {
                type: BooleanConstructor;
                default: boolean;
            };
            visibleItemLimit: {
                type: PropType<number | null>;
                default: null;
            };
            showThumbnail: {
                type: BooleanConstructor;
                default: boolean;
            };
            boldLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideDescriptionOverflow: {
                type: BooleanConstructor;
                default: boolean;
            };
            searchQuery: {
                type: StringConstructor;
                default: string;
            };
            showNoResultsSlot: {
                type: PropType<boolean | null>;
                default: null;
            };
            renderInPlace: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            "onUpdate:selected"?: ((...args: any[]) => any) | undefined;
            "onUpdate:expanded"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-click"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-keyboard-navigation"?: ((...args: any[]) => any) | undefined;
            "onLoad-more"?: ((...args: any[]) => any) | undefined;
        }>, {
            listBoxStyle: import("vue").ComputedRef<{
                'max-height': string | undefined;
                'margin-bottom': string | undefined;
            }>;
            rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
            rootStyle: import("vue").ComputedRef<import("vue").StyleValue>;
            otherAttrs: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            assignTemplateRef: (templateRef: import("vue").ComponentPublicInstance | Element | null, index: number) => void;
            computedMenuEntries: import("vue").ComputedRef<(import("../../types").MenuItemDataWithId | import("../../types").MenuGroupDataWithIds)[]>;
            computedMenuItems: import("vue").ComputedRef<import("../../types").MenuItemDataWithId[]>;
            computedShowNoResultsSlot: import("vue").ComputedRef<boolean>;
            highlightedMenuItem: import("vue").Ref<{
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null, import("../../types").MenuItemDataWithId | {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null>;
            highlightedViaKeyboard: import("vue").Ref<boolean, boolean>;
            teleportDisabled: import("vue").ComputedRef<boolean>;
            computedTarget: import("vue").ComputedRef<string | HTMLElement>;
            handleMenuItemChange: (menuState: import("../../types").MenuState, menuItem: import("../../types").MenuItemDataWithId | null) => void;
            handleKeyNavigation: (e: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }) => boolean;
            ariaRelevant: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
            isMultiselect: import("vue").ComputedRef<boolean>;
            rootElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            menuListbox: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            getGroupWrapperClasses: (group: import("../../types").MenuGroupData) => {
                'cdx-menu__group-wrapper--hide-label': boolean;
            };
            getMenuItemIndex: (menuItem: import("../../types").MenuItemDataWithId) => number;
            getMenuItemBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string;
                match?: string;
                supportingText?: string;
                description?: string | null;
                language?: import("../../types").MenuItemLanguageData;
                icon?: import("@wikimedia/codex-icons").Icon;
                thumbnail?: import("../../types").Thumbnail | null;
                url?: string;
                urlNewTab?: boolean;
                disabled?: boolean;
                selected: boolean;
                active: boolean;
                highlighted: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                searchQuery: string;
                multiselect: boolean;
            };
            getMenuItemHandlers: (menuItem: import("../../types").MenuItemDataWithId) => {
                change: (menuState: import("../../types").MenuState, setState: boolean) => void;
                click: () => void;
            };
            getSlotBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                menuItem: import("../../types").MenuItemDataWithId;
                active: boolean;
            };
            isMenuGroupData: (menuEntry: import("../../types").MenuItemData | import("../../types").MenuGroupData) => menuEntry is import("../../types").MenuGroupData;
        }, {}, {}, {
            isExpanded(): boolean;
            getRootElement(): HTMLElement | undefined;
            getHighlightedMenuItem(): import("../../types").MenuItemDataWithId | null;
            getHighlightedViaKeyboard(): boolean;
            getComputedMenuItems(): import("../../types").MenuItemDataWithId[];
            clearActive(): void;
            delegateKeyNavigation(event: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }): boolean;
        }, {
            footer: import("../../types").MenuItemData;
            searchQuery: string;
            showThumbnail: boolean;
            boldLabel: boolean;
            hideDescriptionOverflow: boolean;
            showPending: boolean;
            visibleItemLimit: number | null;
            showNoResultsSlot: boolean | null;
            renderInPlace: boolean;
        }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
            menuItems: {
                type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
                required: true;
            };
            footer: {
                type: PropType<import("../../types").MenuItemData>;
                default: null;
            };
            selected: {
                type: PropType<import("../../types").MenuItemValue | import("../../types").MenuItemValue[] | null>;
                required: true;
            };
            expanded: {
                type: BooleanConstructor;
                required: true;
            };
            showPending: {
                type: BooleanConstructor;
                default: boolean;
            };
            visibleItemLimit: {
                type: PropType<number | null>;
                default: null;
            };
            showThumbnail: {
                type: BooleanConstructor;
                default: boolean;
            };
            boldLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideDescriptionOverflow: {
                type: BooleanConstructor;
                default: boolean;
            };
            searchQuery: {
                type: StringConstructor;
                default: string;
            };
            showNoResultsSlot: {
                type: PropType<boolean | null>;
                default: null;
            };
            renderInPlace: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            "onUpdate:selected"?: ((...args: any[]) => any) | undefined;
            "onUpdate:expanded"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-click"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-keyboard-navigation"?: ((...args: any[]) => any) | undefined;
            "onLoad-more"?: ((...args: any[]) => any) | undefined;
        }>, {
            listBoxStyle: import("vue").ComputedRef<{
                'max-height': string | undefined;
                'margin-bottom': string | undefined;
            }>;
            rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
            rootStyle: import("vue").ComputedRef<import("vue").StyleValue>;
            otherAttrs: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            assignTemplateRef: (templateRef: import("vue").ComponentPublicInstance | Element | null, index: number) => void;
            computedMenuEntries: import("vue").ComputedRef<(import("../../types").MenuItemDataWithId | import("../../types").MenuGroupDataWithIds)[]>;
            computedMenuItems: import("vue").ComputedRef<import("../../types").MenuItemDataWithId[]>;
            computedShowNoResultsSlot: import("vue").ComputedRef<boolean>;
            highlightedMenuItem: import("vue").Ref<{
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null, import("../../types").MenuItemDataWithId | {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null>;
            highlightedViaKeyboard: import("vue").Ref<boolean, boolean>;
            teleportDisabled: import("vue").ComputedRef<boolean>;
            computedTarget: import("vue").ComputedRef<string | HTMLElement>;
            handleMenuItemChange: (menuState: import("../../types").MenuState, menuItem: import("../../types").MenuItemDataWithId | null) => void;
            handleKeyNavigation: (e: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }) => boolean;
            ariaRelevant: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
            isMultiselect: import("vue").ComputedRef<boolean>;
            rootElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            menuListbox: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            getGroupWrapperClasses: (group: import("../../types").MenuGroupData) => {
                'cdx-menu__group-wrapper--hide-label': boolean;
            };
            getMenuItemIndex: (menuItem: import("../../types").MenuItemDataWithId) => number;
            getMenuItemBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string;
                match?: string;
                supportingText?: string;
                description?: string | null;
                language?: import("../../types").MenuItemLanguageData;
                icon?: import("@wikimedia/codex-icons").Icon;
                thumbnail?: import("../../types").Thumbnail | null;
                url?: string;
                urlNewTab?: boolean;
                disabled?: boolean;
                selected: boolean;
                active: boolean;
                highlighted: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                searchQuery: string;
                multiselect: boolean;
            };
            getMenuItemHandlers: (menuItem: import("../../types").MenuItemDataWithId) => {
                change: (menuState: import("../../types").MenuState, setState: boolean) => void;
                click: () => void;
            };
            getSlotBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                menuItem: import("../../types").MenuItemDataWithId;
                active: boolean;
            };
            isMenuGroupData: (menuEntry: import("../../types").MenuItemData | import("../../types").MenuGroupData) => menuEntry is import("../../types").MenuGroupData;
        }, {}, {}, {
            isExpanded(): boolean;
            getRootElement(): HTMLElement | undefined;
            getHighlightedMenuItem(): import("../../types").MenuItemDataWithId | null;
            getHighlightedViaKeyboard(): boolean;
            getComputedMenuItems(): import("../../types").MenuItemDataWithId[];
            clearActive(): void;
            delegateKeyNavigation(event: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }): boolean;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:selected" | "update:expanded" | "menu-item-click" | "menu-item-keyboard-navigation" | "load-more")[], import("vue").PublicProps, {
            footer: import("../../types").MenuItemData;
            searchQuery: string;
            showThumbnail: boolean;
            boldLabel: boolean;
            hideDescriptionOverflow: boolean;
            showPending: boolean;
            visibleItemLimit: number | null;
            showNoResultsSlot: boolean | null;
            renderInPlace: boolean;
        }, true, {}, {}, {
            CdxMenuItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: PropType<import("../../types").MenuItemValue>;
                    required: true;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selected: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                active: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                highlighted: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                match: {
                    type: StringConstructor;
                    default: string;
                };
                supportingText: {
                    type: StringConstructor;
                    default: string;
                };
                url: {
                    type: StringConstructor;
                    default: string;
                };
                urlNewTab: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    default: string;
                };
                showThumbnail: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                thumbnail: {
                    type: PropType<import("../../types").Thumbnail | null>;
                    default: null;
                };
                description: {
                    type: PropType<string | null>;
                    default: string;
                };
                searchQuery: {
                    type: StringConstructor;
                    default: string;
                };
                boldLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideDescriptionOverflow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                language: {
                    type: PropType<import("../../types").MenuItemLanguageData>;
                    default: () => {};
                };
                action: {
                    type: PropType<import("../../types").ButtonAction>;
                    default: string;
                };
                multiselect: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                onMouseMove: () => void;
                onMouseLeave: () => void;
                onMouseDown: (e: MouseEvent) => void;
                onClick: () => void;
                highlightQuery: import("vue").ComputedRef<boolean>;
                rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
                contentTag: import("vue").ComputedRef<"span" | "a">;
                linkAttrs: import("vue").ComputedRef<{
                    target: string;
                    rel: string;
                } | {
                    target?: undefined;
                    rel?: undefined;
                }>;
                title: import("vue").ComputedRef<string>;
                cdxIconCheck: string;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: PropType<import("../../types").MenuItemValue>;
                    required: true;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selected: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                active: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                highlighted: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                match: {
                    type: StringConstructor;
                    default: string;
                };
                supportingText: {
                    type: StringConstructor;
                    default: string;
                };
                url: {
                    type: StringConstructor;
                    default: string;
                };
                urlNewTab: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    default: string;
                };
                showThumbnail: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                thumbnail: {
                    type: PropType<import("../../types").Thumbnail | null>;
                    default: null;
                };
                description: {
                    type: PropType<string | null>;
                    default: string;
                };
                searchQuery: {
                    type: StringConstructor;
                    default: string;
                };
                boldLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideDescriptionOverflow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                language: {
                    type: PropType<import("../../types").MenuItemLanguageData>;
                    default: () => {};
                };
                action: {
                    type: PropType<import("../../types").ButtonAction>;
                    default: string;
                };
                multiselect: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onChange?: ((...args: any[]) => any) | undefined;
            }>, {
                url: string;
                selected: boolean;
                highlighted: boolean;
                active: boolean;
                icon: import("@wikimedia/codex-icons").Icon;
                label: string;
                match: string;
                action: "default" | "progressive" | "destructive";
                disabled: boolean;
                thumbnail: import("../../types").Thumbnail | null;
                description: string | null;
                searchQuery: string;
                supportingText: string;
                urlNewTab: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                language: import("../../types").MenuItemLanguageData;
                multiselect: boolean;
            }, {}, {
                CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    icon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        required: true;
                    };
                    iconLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    lang: {
                        type: PropType<string | null>;
                        default: null;
                    };
                    dir: {
                        type: PropType<import("../../types").HTMLDirection | null>;
                        default: null;
                    };
                    size: {
                        type: PropType<import("../../types").IconSize>;
                        default: string;
                        validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                    };
                }>, {
                    rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                    rootClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'cdx-icon--flipped': boolean;
                    }>;
                    iconSvg: import("vue").ComputedRef<string>;
                    iconPath: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    icon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        required: true;
                    };
                    iconLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    lang: {
                        type: PropType<string | null>;
                        default: null;
                    };
                    dir: {
                        type: PropType<import("../../types").HTMLDirection | null>;
                        default: null;
                    };
                    size: {
                        type: PropType<import("../../types").IconSize>;
                        default: string;
                        validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                    };
                }>> & Readonly<{}>, {
                    lang: string | null;
                    iconLabel: string;
                    dir: import("../../types").HTMLDirection | null;
                    size: "medium" | "small" | "x-small";
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                CdxThumbnail: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    thumbnail: {
                        type: PropType<import("../../types").Thumbnail | null>;
                        default: null;
                    };
                    placeholderIcon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        default: string;
                    };
                }>, {
                    thumbnailStyle: import("vue").Ref<{}, {}>;
                    thumbnailLoaded: import("vue").Ref<boolean, boolean>;
                    NoInvertClass: "cdx-no-invert";
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    thumbnail: {
                        type: PropType<import("../../types").Thumbnail | null>;
                        default: null;
                    };
                    placeholderIcon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        default: string;
                    };
                }>> & Readonly<{}>, {
                    thumbnail: import("../../types").Thumbnail | null;
                    placeholderIcon: import("@wikimedia/codex-icons").Icon;
                }, {}, {
                    CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        icon: {
                            type: PropType<import("@wikimedia/codex-icons").Icon>;
                            required: true;
                        };
                        iconLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        lang: {
                            type: PropType<string | null>;
                            default: null;
                        };
                        dir: {
                            type: PropType<import("../../types").HTMLDirection | null>;
                            default: null;
                        };
                        size: {
                            type: PropType<import("../../types").IconSize>;
                            default: string;
                            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                        };
                    }>, {
                        rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                        rootClasses: import("vue").ComputedRef<{
                            [x: string]: boolean;
                            'cdx-icon--flipped': boolean;
                        }>;
                        iconSvg: import("vue").ComputedRef<string>;
                        iconPath: import("vue").ComputedRef<string>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        icon: {
                            type: PropType<import("@wikimedia/codex-icons").Icon>;
                            required: true;
                        };
                        iconLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        lang: {
                            type: PropType<string | null>;
                            default: null;
                        };
                        dir: {
                            type: PropType<import("../../types").HTMLDirection | null>;
                            default: null;
                        };
                        size: {
                            type: PropType<import("../../types").IconSize>;
                            default: string;
                            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                        };
                    }>> & Readonly<{}>, {
                        lang: string | null;
                        iconLabel: string;
                        dir: import("../../types").HTMLDirection | null;
                        size: "medium" | "small" | "x-small";
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                CdxSearchResultTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    title: {
                        type: StringConstructor;
                        required: true;
                    };
                    searchQuery: {
                        type: StringConstructor;
                        default: string;
                    };
                }>, {
                    titleChunks: import("vue").ComputedRef<[string, string, string]>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    title: {
                        type: StringConstructor;
                        required: true;
                    };
                    searchQuery: {
                        type: StringConstructor;
                        default: string;
                    };
                }>> & Readonly<{}>, {
                    searchQuery: string;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    required: true;
                };
                iconLabel: {
                    type: StringConstructor;
                    default: string;
                };
                lang: {
                    type: PropType<string | null>;
                    default: null;
                };
                dir: {
                    type: PropType<import("../../types").HTMLDirection | null>;
                    default: null;
                };
                size: {
                    type: PropType<import("../../types").IconSize>;
                    default: string;
                    validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                };
            }>, {
                rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                rootClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'cdx-icon--flipped': boolean;
                }>;
                iconSvg: import("vue").ComputedRef<string>;
                iconPath: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    required: true;
                };
                iconLabel: {
                    type: StringConstructor;
                    default: string;
                };
                lang: {
                    type: PropType<string | null>;
                    default: null;
                };
                dir: {
                    type: PropType<import("../../types").HTMLDirection | null>;
                    default: null;
                };
                size: {
                    type: PropType<import("../../types").IconSize>;
                    default: string;
                    validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                };
            }>> & Readonly<{}>, {
                lang: string | null;
                iconLabel: string;
                dir: import("../../types").HTMLDirection | null;
                size: "medium" | "small" | "x-small";
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            CdxProgressBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                value: {
                    type: (NumberConstructor | null)[];
                    default: null;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                inline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                startLabel: {
                    type: StringConstructor;
                    default: string;
                };
                endLabel: {
                    type: StringConstructor;
                    default: string;
                };
            }>, {
                rootClasses: import("vue").ComputedRef<{
                    'cdx-progress-bar--block': boolean;
                    'cdx-progress-bar--inline': boolean;
                    'cdx-progress-bar--enabled': boolean;
                    'cdx-progress-bar--disabled': boolean;
                }>;
                computedAriaHidden: import("vue").ComputedRef<"true" | undefined>;
                hasValue: import("vue").ComputedRef<boolean>;
                progressStyles: import("vue").ComputedRef<{
                    '--cdx-progress-value': number;
                    '--cdx-progress-max': number;
                }>;
                clampedValue: import("vue").ComputedRef<number>;
                labelsId: string;
                ariaLabelledBy: import("vue").ComputedRef<string | undefined>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                value: {
                    type: (NumberConstructor | null)[];
                    default: null;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                inline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                startLabel: {
                    type: StringConstructor;
                    default: string;
                };
                endLabel: {
                    type: StringConstructor;
                    default: string;
                };
            }>> & Readonly<{}>, {
                disabled: boolean;
                value: number | null;
                inline: boolean;
                max: number;
                startLabel: string;
                endLabel: string;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("vue").ExtractPropTypes<{
            menuItems: {
                type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
                required: true;
            };
            footer: {
                type: PropType<import("../../types").MenuItemData>;
                default: null;
            };
            selected: {
                type: PropType<import("../../types").MenuItemValue | import("../../types").MenuItemValue[] | null>;
                required: true;
            };
            expanded: {
                type: BooleanConstructor;
                required: true;
            };
            showPending: {
                type: BooleanConstructor;
                default: boolean;
            };
            visibleItemLimit: {
                type: PropType<number | null>;
                default: null;
            };
            showThumbnail: {
                type: BooleanConstructor;
                default: boolean;
            };
            boldLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideDescriptionOverflow: {
                type: BooleanConstructor;
                default: boolean;
            };
            searchQuery: {
                type: StringConstructor;
                default: string;
            };
            showNoResultsSlot: {
                type: PropType<boolean | null>;
                default: null;
            };
            renderInPlace: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            "onUpdate:selected"?: ((...args: any[]) => any) | undefined;
            "onUpdate:expanded"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-click"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-keyboard-navigation"?: ((...args: any[]) => any) | undefined;
            "onLoad-more"?: ((...args: any[]) => any) | undefined;
        }>, {
            listBoxStyle: import("vue").ComputedRef<{
                'max-height': string | undefined;
                'margin-bottom': string | undefined;
            }>;
            rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
            rootStyle: import("vue").ComputedRef<import("vue").StyleValue>;
            otherAttrs: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            assignTemplateRef: (templateRef: import("vue").ComponentPublicInstance | Element | null, index: number) => void;
            computedMenuEntries: import("vue").ComputedRef<(import("../../types").MenuItemDataWithId | import("../../types").MenuGroupDataWithIds)[]>;
            computedMenuItems: import("vue").ComputedRef<import("../../types").MenuItemDataWithId[]>;
            computedShowNoResultsSlot: import("vue").ComputedRef<boolean>;
            highlightedMenuItem: import("vue").Ref<{
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null, import("../../types").MenuItemDataWithId | {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null>;
            highlightedViaKeyboard: import("vue").Ref<boolean, boolean>;
            teleportDisabled: import("vue").ComputedRef<boolean>;
            computedTarget: import("vue").ComputedRef<string | HTMLElement>;
            handleMenuItemChange: (menuState: import("../../types").MenuState, menuItem: import("../../types").MenuItemDataWithId | null) => void;
            handleKeyNavigation: (e: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }) => boolean;
            ariaRelevant: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
            isMultiselect: import("vue").ComputedRef<boolean>;
            rootElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            menuListbox: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            getGroupWrapperClasses: (group: import("../../types").MenuGroupData) => {
                'cdx-menu__group-wrapper--hide-label': boolean;
            };
            getMenuItemIndex: (menuItem: import("../../types").MenuItemDataWithId) => number;
            getMenuItemBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string;
                match?: string;
                supportingText?: string;
                description?: string | null;
                language?: import("../../types").MenuItemLanguageData;
                icon?: import("@wikimedia/codex-icons").Icon;
                thumbnail?: import("../../types").Thumbnail | null;
                url?: string;
                urlNewTab?: boolean;
                disabled?: boolean;
                selected: boolean;
                active: boolean;
                highlighted: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                searchQuery: string;
                multiselect: boolean;
            };
            getMenuItemHandlers: (menuItem: import("../../types").MenuItemDataWithId) => {
                change: (menuState: import("../../types").MenuState, setState: boolean) => void;
                click: () => void;
            };
            getSlotBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                menuItem: import("../../types").MenuItemDataWithId;
                active: boolean;
            };
            isMenuGroupData: (menuEntry: import("../../types").MenuItemData | import("../../types").MenuGroupData) => menuEntry is import("../../types").MenuGroupData;
        }, {}, {}, {
            isExpanded(): boolean;
            getRootElement(): HTMLElement | undefined;
            getHighlightedMenuItem(): import("../../types").MenuItemDataWithId | null;
            getHighlightedViaKeyboard(): boolean;
            getComputedMenuItems(): import("../../types").MenuItemDataWithId[];
            clearActive(): void;
            delegateKeyNavigation(event: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }): boolean;
        }, {
            footer: import("../../types").MenuItemData;
            searchQuery: string;
            showThumbnail: boolean;
            boldLabel: boolean;
            hideDescriptionOverflow: boolean;
            showPending: boolean;
            visibleItemLimit: number | null;
            showNoResultsSlot: boolean | null;
            renderInPlace: boolean;
        }> | undefined>;
        computedHandleId: import("vue").ComputedRef<string | undefined>;
        descriptionId: import("vue").ComputedRef<string | undefined> | undefined;
        menuId: string;
        modelWrapper: import("vue").WritableComputedRef<string | number | null, string | number | null>;
        selectedMenuItem: import("vue").ComputedRef<import("../../types").MenuItemDataWithId | undefined>;
        highlightedId: import("vue").ComputedRef<string | undefined>;
        expanded: import("vue").Ref<boolean, boolean>;
        computedDisabled: import("vue").ComputedRef<boolean>;
        onBlur: () => void;
        currentLabel: import("vue").ComputedRef<import("../../types").MenuItemValue>;
        rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
        rootStyle: import("vue").ComputedRef<import("vue").StyleValue>;
        otherAttrsMinusId: import("vue").ComputedRef<{
            [x: string]: unknown;
        }>;
        onClick: () => void;
        onKeydown: (e: KeyboardEvent) => void;
        startIcon: import("vue").ComputedRef<import("@wikimedia/codex-icons").Icon | undefined>;
        cdxIconExpand: string;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:selected" | "load-more")[], "update:selected" | "load-more", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        menuItems: {
            type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
            required: true;
        };
        selected: {
            type: PropType<string | number | null>;
            required: true;
        };
        defaultLabel: {
            type: StringConstructor;
            default: string;
        };
        name: {
            type: StringConstructor;
            default: undefined;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        menuConfig: {
            type: PropType<import("../../types").MenuConfig>;
            default: () => import("../../types").MenuConfig;
        };
        defaultIcon: {
            type: PropType<import("@wikimedia/codex-icons").Icon>;
            default: undefined;
        };
        status: {
            type: PropType<import("../../types").ValidationStatusType>;
            default: string;
            validator: import("../../types").StringTypeValidator<"default" | "warning" | "error" | "success">;
        };
    }>> & Readonly<{
        "onUpdate:selected"?: ((...args: any[]) => any) | undefined;
        "onLoad-more"?: ((...args: any[]) => any) | undefined;
    }>, {
        name: string;
        disabled: boolean;
        status: "default" | "warning" | "error" | "success";
        menuConfig: import("../../types").MenuConfig;
        defaultLabel: string;
        defaultIcon: import("@wikimedia/codex-icons").Icon;
    }, {}, {
        CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            icon: {
                type: PropType<import("@wikimedia/codex-icons").Icon>;
                required: true;
            };
            iconLabel: {
                type: StringConstructor;
                default: string;
            };
            lang: {
                type: PropType<string | null>;
                default: null;
            };
            dir: {
                type: PropType<import("../../types").HTMLDirection | null>;
                default: null;
            };
            size: {
                type: PropType<import("../../types").IconSize>;
                default: string;
                validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
            };
        }>, {
            rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
            rootClasses: import("vue").ComputedRef<{
                [x: string]: boolean;
                'cdx-icon--flipped': boolean;
            }>;
            iconSvg: import("vue").ComputedRef<string>;
            iconPath: import("vue").ComputedRef<string>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            icon: {
                type: PropType<import("@wikimedia/codex-icons").Icon>;
                required: true;
            };
            iconLabel: {
                type: StringConstructor;
                default: string;
            };
            lang: {
                type: PropType<string | null>;
                default: null;
            };
            dir: {
                type: PropType<import("../../types").HTMLDirection | null>;
                default: null;
            };
            size: {
                type: PropType<import("../../types").IconSize>;
                default: string;
                validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
            };
        }>> & Readonly<{}>, {
            lang: string | null;
            iconLabel: string;
            dir: import("../../types").HTMLDirection | null;
            size: "medium" | "small" | "x-small";
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        CdxMenu: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            menuItems: {
                type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
                required: true;
            };
            footer: {
                type: PropType<import("../../types").MenuItemData>;
                default: null;
            };
            selected: {
                type: PropType<import("../../types").MenuItemValue | import("../../types").MenuItemValue[] | null>;
                required: true;
            };
            expanded: {
                type: BooleanConstructor;
                required: true;
            };
            showPending: {
                type: BooleanConstructor;
                default: boolean;
            };
            visibleItemLimit: {
                type: PropType<number | null>;
                default: null;
            };
            showThumbnail: {
                type: BooleanConstructor;
                default: boolean;
            };
            boldLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideDescriptionOverflow: {
                type: BooleanConstructor;
                default: boolean;
            };
            searchQuery: {
                type: StringConstructor;
                default: string;
            };
            showNoResultsSlot: {
                type: PropType<boolean | null>;
                default: null;
            };
            renderInPlace: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            listBoxStyle: import("vue").ComputedRef<{
                'max-height': string | undefined;
                'margin-bottom': string | undefined;
            }>;
            rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
            rootStyle: import("vue").ComputedRef<import("vue").StyleValue>;
            otherAttrs: import("vue").ComputedRef<{
                [x: string]: unknown;
            }>;
            assignTemplateRef: (templateRef: import("vue").ComponentPublicInstance | Element | null, index: number) => void;
            computedMenuEntries: import("vue").ComputedRef<(import("../../types").MenuItemDataWithId | import("../../types").MenuGroupDataWithIds)[]>;
            computedMenuItems: import("vue").ComputedRef<import("../../types").MenuItemDataWithId[]>;
            computedShowNoResultsSlot: import("vue").ComputedRef<boolean>;
            highlightedMenuItem: import("vue").Ref<{
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null, import("../../types").MenuItemDataWithId | {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string | undefined;
                match?: string | undefined;
                supportingText?: string | undefined;
                description?: string | null | undefined;
                language?: {
                    label?: string | undefined;
                    match?: string | undefined;
                    supportingText?: string | undefined;
                    description?: string | undefined;
                } | undefined;
                icon?: string | {
                    path: string;
                } | {
                    ltr: string | {
                        path: string;
                    };
                    shouldFlip: true;
                    shouldFlipExceptions?: string[] | undefined;
                } | {
                    rtl: string | {
                        path: string;
                    };
                    ltr: string | {
                        path: string;
                    };
                } | {
                    langCodeMap: Record<string, import("@wikimedia/codex-icons").SimpleIcon | import("@wikimedia/codex-icons").IconFlipForRtl>;
                    default: string | {
                        path: string;
                    } | {
                        ltr: string | {
                            path: string;
                        };
                        shouldFlip: true;
                        shouldFlipExceptions?: string[] | undefined;
                    };
                } | undefined;
                thumbnail?: {
                    url: string;
                } | null | undefined;
                url?: string | undefined;
                urlNewTab?: boolean | undefined;
                disabled?: boolean | undefined;
            } | null>;
            highlightedViaKeyboard: import("vue").Ref<boolean, boolean>;
            teleportDisabled: import("vue").ComputedRef<boolean>;
            computedTarget: import("vue").ComputedRef<string | HTMLElement>;
            handleMenuItemChange: (menuState: import("../../types").MenuState, menuItem: import("../../types").MenuItemDataWithId | null) => void;
            handleKeyNavigation: (e: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }) => boolean;
            ariaRelevant: "text" | "all" | "additions" | "additions removals" | "additions text" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
            isMultiselect: import("vue").ComputedRef<boolean>;
            rootElement: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            menuListbox: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
            getGroupWrapperClasses: (group: import("../../types").MenuGroupData) => {
                'cdx-menu__group-wrapper--hide-label': boolean;
            };
            getMenuItemIndex: (menuItem: import("../../types").MenuItemDataWithId) => number;
            getMenuItemBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                id: string;
                value: import("../../types").MenuItemValue;
                label?: string;
                match?: string;
                supportingText?: string;
                description?: string | null;
                language?: import("../../types").MenuItemLanguageData;
                icon?: import("@wikimedia/codex-icons").Icon;
                thumbnail?: import("../../types").Thumbnail | null;
                url?: string;
                urlNewTab?: boolean;
                disabled?: boolean;
                selected: boolean;
                active: boolean;
                highlighted: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                searchQuery: string;
                multiselect: boolean;
            };
            getMenuItemHandlers: (menuItem: import("../../types").MenuItemDataWithId) => {
                change: (menuState: import("../../types").MenuState, setState: boolean) => void;
                click: () => void;
            };
            getSlotBindings: (menuItem: import("../../types").MenuItemDataWithId) => {
                menuItem: import("../../types").MenuItemDataWithId;
                active: boolean;
            };
            isMenuGroupData: (menuEntry: import("../../types").MenuItemData | import("../../types").MenuGroupData) => menuEntry is import("../../types").MenuGroupData;
        }, {}, {}, {
            isExpanded(): boolean;
            getRootElement(): HTMLElement | undefined;
            getHighlightedMenuItem(): import("../../types").MenuItemDataWithId | null;
            getHighlightedViaKeyboard(): boolean;
            getComputedMenuItems(): import("../../types").MenuItemDataWithId[];
            clearActive(): void;
            delegateKeyNavigation(event: KeyboardEvent, { prevent, characterNavigation }?: {
                prevent?: boolean | undefined;
                characterNavigation?: boolean | undefined;
            }): boolean;
        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:selected" | "update:expanded" | "menu-item-click" | "menu-item-keyboard-navigation" | "load-more")[], "update:selected" | "update:expanded" | "menu-item-click" | "menu-item-keyboard-navigation" | "load-more", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            menuItems: {
                type: PropType<(import("../../types").MenuItemData | import("../../types").MenuGroupData)[]>;
                required: true;
            };
            footer: {
                type: PropType<import("../../types").MenuItemData>;
                default: null;
            };
            selected: {
                type: PropType<import("../../types").MenuItemValue | import("../../types").MenuItemValue[] | null>;
                required: true;
            };
            expanded: {
                type: BooleanConstructor;
                required: true;
            };
            showPending: {
                type: BooleanConstructor;
                default: boolean;
            };
            visibleItemLimit: {
                type: PropType<number | null>;
                default: null;
            };
            showThumbnail: {
                type: BooleanConstructor;
                default: boolean;
            };
            boldLabel: {
                type: BooleanConstructor;
                default: boolean;
            };
            hideDescriptionOverflow: {
                type: BooleanConstructor;
                default: boolean;
            };
            searchQuery: {
                type: StringConstructor;
                default: string;
            };
            showNoResultsSlot: {
                type: PropType<boolean | null>;
                default: null;
            };
            renderInPlace: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            "onUpdate:selected"?: ((...args: any[]) => any) | undefined;
            "onUpdate:expanded"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-click"?: ((...args: any[]) => any) | undefined;
            "onMenu-item-keyboard-navigation"?: ((...args: any[]) => any) | undefined;
            "onLoad-more"?: ((...args: any[]) => any) | undefined;
        }>, {
            footer: import("../../types").MenuItemData;
            searchQuery: string;
            showThumbnail: boolean;
            boldLabel: boolean;
            hideDescriptionOverflow: boolean;
            showPending: boolean;
            visibleItemLimit: number | null;
            showNoResultsSlot: boolean | null;
            renderInPlace: boolean;
        }, {}, {
            CdxMenuItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: PropType<import("../../types").MenuItemValue>;
                    required: true;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selected: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                active: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                highlighted: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                match: {
                    type: StringConstructor;
                    default: string;
                };
                supportingText: {
                    type: StringConstructor;
                    default: string;
                };
                url: {
                    type: StringConstructor;
                    default: string;
                };
                urlNewTab: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    default: string;
                };
                showThumbnail: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                thumbnail: {
                    type: PropType<import("../../types").Thumbnail | null>;
                    default: null;
                };
                description: {
                    type: PropType<string | null>;
                    default: string;
                };
                searchQuery: {
                    type: StringConstructor;
                    default: string;
                };
                boldLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideDescriptionOverflow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                language: {
                    type: PropType<import("../../types").MenuItemLanguageData>;
                    default: () => {};
                };
                action: {
                    type: PropType<import("../../types").ButtonAction>;
                    default: string;
                };
                multiselect: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                onMouseMove: () => void;
                onMouseLeave: () => void;
                onMouseDown: (e: MouseEvent) => void;
                onClick: () => void;
                highlightQuery: import("vue").ComputedRef<boolean>;
                rootClasses: import("vue").ComputedRef<Record<string, boolean>>;
                contentTag: import("vue").ComputedRef<"span" | "a">;
                linkAttrs: import("vue").ComputedRef<{
                    target: string;
                    rel: string;
                } | {
                    target?: undefined;
                    rel?: undefined;
                }>;
                title: import("vue").ComputedRef<string>;
                cdxIconCheck: string;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                id: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: PropType<import("../../types").MenuItemValue>;
                    required: true;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                selected: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                active: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                highlighted: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                label: {
                    type: StringConstructor;
                    default: string;
                };
                match: {
                    type: StringConstructor;
                    default: string;
                };
                supportingText: {
                    type: StringConstructor;
                    default: string;
                };
                url: {
                    type: StringConstructor;
                    default: string;
                };
                urlNewTab: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    default: string;
                };
                showThumbnail: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                thumbnail: {
                    type: PropType<import("../../types").Thumbnail | null>;
                    default: null;
                };
                description: {
                    type: PropType<string | null>;
                    default: string;
                };
                searchQuery: {
                    type: StringConstructor;
                    default: string;
                };
                boldLabel: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideDescriptionOverflow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                language: {
                    type: PropType<import("../../types").MenuItemLanguageData>;
                    default: () => {};
                };
                action: {
                    type: PropType<import("../../types").ButtonAction>;
                    default: string;
                };
                multiselect: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onChange?: ((...args: any[]) => any) | undefined;
            }>, {
                url: string;
                selected: boolean;
                highlighted: boolean;
                active: boolean;
                icon: import("@wikimedia/codex-icons").Icon;
                label: string;
                match: string;
                action: "default" | "progressive" | "destructive";
                disabled: boolean;
                thumbnail: import("../../types").Thumbnail | null;
                description: string | null;
                searchQuery: string;
                supportingText: string;
                urlNewTab: boolean;
                showThumbnail: boolean;
                boldLabel: boolean;
                hideDescriptionOverflow: boolean;
                language: import("../../types").MenuItemLanguageData;
                multiselect: boolean;
            }, {}, {
                CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    icon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        required: true;
                    };
                    iconLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    lang: {
                        type: PropType<string | null>;
                        default: null;
                    };
                    dir: {
                        type: PropType<import("../../types").HTMLDirection | null>;
                        default: null;
                    };
                    size: {
                        type: PropType<import("../../types").IconSize>;
                        default: string;
                        validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                    };
                }>, {
                    rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                    rootClasses: import("vue").ComputedRef<{
                        [x: string]: boolean;
                        'cdx-icon--flipped': boolean;
                    }>;
                    iconSvg: import("vue").ComputedRef<string>;
                    iconPath: import("vue").ComputedRef<string>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    icon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        required: true;
                    };
                    iconLabel: {
                        type: StringConstructor;
                        default: string;
                    };
                    lang: {
                        type: PropType<string | null>;
                        default: null;
                    };
                    dir: {
                        type: PropType<import("../../types").HTMLDirection | null>;
                        default: null;
                    };
                    size: {
                        type: PropType<import("../../types").IconSize>;
                        default: string;
                        validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                    };
                }>> & Readonly<{}>, {
                    lang: string | null;
                    iconLabel: string;
                    dir: import("../../types").HTMLDirection | null;
                    size: "medium" | "small" | "x-small";
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                CdxThumbnail: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    thumbnail: {
                        type: PropType<import("../../types").Thumbnail | null>;
                        default: null;
                    };
                    placeholderIcon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        default: string;
                    };
                }>, {
                    thumbnailStyle: import("vue").Ref<{}, {}>;
                    thumbnailLoaded: import("vue").Ref<boolean, boolean>;
                    NoInvertClass: "cdx-no-invert";
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    thumbnail: {
                        type: PropType<import("../../types").Thumbnail | null>;
                        default: null;
                    };
                    placeholderIcon: {
                        type: PropType<import("@wikimedia/codex-icons").Icon>;
                        default: string;
                    };
                }>> & Readonly<{}>, {
                    thumbnail: import("../../types").Thumbnail | null;
                    placeholderIcon: import("@wikimedia/codex-icons").Icon;
                }, {}, {
                    CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        icon: {
                            type: PropType<import("@wikimedia/codex-icons").Icon>;
                            required: true;
                        };
                        iconLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        lang: {
                            type: PropType<string | null>;
                            default: null;
                        };
                        dir: {
                            type: PropType<import("../../types").HTMLDirection | null>;
                            default: null;
                        };
                        size: {
                            type: PropType<import("../../types").IconSize>;
                            default: string;
                            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                        };
                    }>, {
                        rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                        rootClasses: import("vue").ComputedRef<{
                            [x: string]: boolean;
                            'cdx-icon--flipped': boolean;
                        }>;
                        iconSvg: import("vue").ComputedRef<string>;
                        iconPath: import("vue").ComputedRef<string>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        icon: {
                            type: PropType<import("@wikimedia/codex-icons").Icon>;
                            required: true;
                        };
                        iconLabel: {
                            type: StringConstructor;
                            default: string;
                        };
                        lang: {
                            type: PropType<string | null>;
                            default: null;
                        };
                        dir: {
                            type: PropType<import("../../types").HTMLDirection | null>;
                            default: null;
                        };
                        size: {
                            type: PropType<import("../../types").IconSize>;
                            default: string;
                            validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                        };
                    }>> & Readonly<{}>, {
                        lang: string | null;
                        iconLabel: string;
                        dir: import("../../types").HTMLDirection | null;
                        size: "medium" | "small" | "x-small";
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                CdxSearchResultTitle: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    title: {
                        type: StringConstructor;
                        required: true;
                    };
                    searchQuery: {
                        type: StringConstructor;
                        default: string;
                    };
                }>, {
                    titleChunks: import("vue").ComputedRef<[string, string, string]>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    title: {
                        type: StringConstructor;
                        required: true;
                    };
                    searchQuery: {
                        type: StringConstructor;
                        default: string;
                    };
                }>> & Readonly<{}>, {
                    searchQuery: string;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            CdxIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    required: true;
                };
                iconLabel: {
                    type: StringConstructor;
                    default: string;
                };
                lang: {
                    type: PropType<string | null>;
                    default: null;
                };
                dir: {
                    type: PropType<import("../../types").HTMLDirection | null>;
                    default: null;
                };
                size: {
                    type: PropType<import("../../types").IconSize>;
                    default: string;
                    validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                };
            }>, {
                rootElement: import("vue").Ref<HTMLSpanElement | undefined, HTMLSpanElement | undefined>;
                rootClasses: import("vue").ComputedRef<{
                    [x: string]: boolean;
                    'cdx-icon--flipped': boolean;
                }>;
                iconSvg: import("vue").ComputedRef<string>;
                iconPath: import("vue").ComputedRef<string>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                icon: {
                    type: PropType<import("@wikimedia/codex-icons").Icon>;
                    required: true;
                };
                iconLabel: {
                    type: StringConstructor;
                    default: string;
                };
                lang: {
                    type: PropType<string | null>;
                    default: null;
                };
                dir: {
                    type: PropType<import("../../types").HTMLDirection | null>;
                    default: null;
                };
                size: {
                    type: PropType<import("../../types").IconSize>;
                    default: string;
                    validator: import("../../types").StringTypeValidator<"medium" | "small" | "x-small">;
                };
            }>> & Readonly<{}>, {
                lang: string | null;
                iconLabel: string;
                dir: import("../../types").HTMLDirection | null;
                size: "medium" | "small" | "x-small";
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            CdxProgressBar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                value: {
                    type: (NumberConstructor | null)[];
                    default: null;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                inline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                startLabel: {
                    type: StringConstructor;
                    default: string;
                };
                endLabel: {
                    type: StringConstructor;
                    default: string;
                };
            }>, {
                rootClasses: import("vue").ComputedRef<{
                    'cdx-progress-bar--block': boolean;
                    'cdx-progress-bar--inline': boolean;
                    'cdx-progress-bar--enabled': boolean;
                    'cdx-progress-bar--disabled': boolean;
                }>;
                computedAriaHidden: import("vue").ComputedRef<"true" | undefined>;
                hasValue: import("vue").ComputedRef<boolean>;
                progressStyles: import("vue").ComputedRef<{
                    '--cdx-progress-value': number;
                    '--cdx-progress-max': number;
                }>;
                clampedValue: import("vue").ComputedRef<number>;
                labelsId: string;
                ariaLabelledBy: import("vue").ComputedRef<string | undefined>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                value: {
                    type: (NumberConstructor | null)[];
                    default: null;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                inline: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                startLabel: {
                    type: StringConstructor;
                    default: string;
                };
                endLabel: {
                    type: StringConstructor;
                    default: string;
                };
            }>> & Readonly<{}>, {
                disabled: boolean;
                value: number | null;
                inline: boolean;
                max: number;
                startLabel: string;
                endLabel: string;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _default;