export { default as BulkActions } from "./_internal/components/ListView/components/BulkActions.vue";
export { default as ListGroup } from "./_internal/components/ListView/components/ListGroup.vue";
export { default as ListHeader } from "./_internal/components/ListView/components/ListHeader.vue";
export { default as LoadingManager } from "./_internal/components/ListView/components/LoadingManager.vue";
declare const _default: typeof __VLS_export;
export default _default;
declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    /**
     * Hide the '{number} of {total} selected' text for bulk actions
     */
    hideNumberOfTotalSelected: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Hide the Select All checkbox for bulk actions
     */
    hideSelectAll: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Text to render in EmptyState component if there are no results
     */
    emptyStateText: {
        type: StringConstructor;
        default: string;
    };
    filterSchema: {
        type: ArrayConstructor;
        default: () => never[];
    };
    /**
     * Make search fuzzy. Only for client side search.
     */
    fuzzySearch: {
        type: BooleanConstructor;
        default: boolean;
    };
    hideTotal: BooleanConstructor;
    initialPage: {
        type: NumberConstructor;
        default: undefined;
    };
    /**
     * Can items on the page be selected for bulk actions
     */
    isSelectable: BooleanConstructor;
    /**
     * For loading data already paginated, filtered (including search), and sorted from a backend.
     * Defining this prop will disable the built-in search, filtering, sorting and pagination.
     * You will instead need to use the available events (`@change`, and `@change:` prefixed)
     * to know when to request new pages from your backend.
     * This requires providing `totalItemCount`.
     * Use the loading prop to indicate when data is being loaded.
     */
    isServerSide: BooleanConstructor;
    /**
     * The data for each row. Used in this file as this.internalItems (a copy) to allow mutation;
     */
    items: {
        type: ArrayConstructor;
        default: () => never[];
    };
    /**
     * Default field to track selected items by
     */
    itemTrackBy: {
        type: StringConstructor;
        default: string;
    };
    loading: BooleanConstructor;
    pageSize: {
        type: NumberConstructor;
        default: number;
    };
    searchSchema: {
        type: ObjectConstructor;
        default: () => {};
    };
    sortLabel: {
        type: StringConstructor;
        default: () => any;
    };
    sortOnLoad: BooleanConstructor;
    sorts: {
        type: ObjectConstructor;
        default: () => {};
    };
    /**
     * Total number of unpaginated results
     * Required when `isServerSide` is `true`
     */
    totalItemCount: {
        type: NumberConstructor;
        default: undefined;
    };
    /**
     * Validation schema function that returns an object
     */
    validationSchema: {
        type: FunctionConstructor;
        default: () => () => undefined;
    };
    /**
     * Whether to disable the sticky filters
     * if disabled, the following will happen
     * 1. pre-selected value(s) can be added to
     * the filter component's attributes to overwrite the sticky filters
     * 2. users will not have sticky filters on the page
     */
    disablePersistency: BooleanConstructor;
    /**
     * Whether to disable the ability of saving 'show-filters'
     * in local storage
     */
    disableShowFilter: BooleanConstructor;
    /**
     * Whether to disable the stickiness of the header.
     * Default is false. When true, neither the list headers nor
     * the bulk actions (when applicable) will be sticky.
     */
    disableStickyHeader: BooleanConstructor;
    /**
     * Whether to expand the filters section by default on load.
     */
    showFiltersOnLoad: BooleanConstructor;
    /**
     * Do not use the LoadingManager, and instead render the default slot as passed
     */
    disableLoader: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Override the header offset used to position the sticky header
     */
    stickyHeaderOffset: {
        type: NumberConstructor;
        default: null;
    };
    /**
     * Prevent bulk actions dropdown from rendering
     */
    hideBulkActionOptions: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * If initial search term is provided, the list will be filtered on load.
     */
    initialSearchTerm: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Function that determines whether the item checkbox is disabled or not (default: false)
     */
    isItemDisabled: {
        type: FunctionConstructor;
        default: () => boolean;
    };
}>, {}, {
    internalItems: never[];
    currentPage: number;
    previousPage: null;
    sortOptionsWidth: number;
    filters: {};
    filterText: any;
    searchFor: () => void;
    searchTerm: string;
    searchText: any;
    sortTerm: string;
    isLoadingSearchSchemaAction: boolean;
    isShowingFilters: boolean;
    isFiltering: boolean;
    results: never[];
    selectedItems: never[];
}, {
    /**
     * Returns true if any of its list items are truthy; otherwise returns false.
     * @returns {boolean}
     */
    isLoading(): boolean;
    totalCount(): number | undefined;
    /**
     * Helps determine if the list is filtered or not when there is an incomplete
     * result list, such as when isServerSide is true.
     */
    isFiltered(): boolean;
    /**
     * Merges the searchSchema with the default value since all attributes are optional
     */
    internalSearchSchema(): {
        searchBy: false | string[];
        isSearchable: boolean;
        placeholder: string;
    };
    /**
     * Start of page
     */
    startIndex(): number;
    /**
     * End of page
     */
    endIndex(): number;
    /**
     * Slices the results set into a paginated segment.
     * @returns One page in the paginated set of results
     */
    paginated(): never[];
    /**
     * Displays a visual indication for the number of results, or "working" if the
     * results are being determined.
     */
    total(): any;
    /**
     * Determines if both #list-header and #list-items slots are used.
     * @returns {boolean}
     */
    useDefinedSlots(): boolean;
    /**
     * Don't show total count if list items are selected and total is not hidden
     */
    shouldShowTotal(): boolean;
    /**
     * Returns a list of the selected items' track by field
     */
    selectedItemIds(): never[];
    /**
     * Returns a list of the paginated items' track by field
     */
    paginatedIds(): never[];
    isAllPageChecked(): boolean;
    isSomePageChecked(): boolean;
    numberOfFilters(): number;
    isSelectBarVisible(): boolean;
    showPrimaryControls(): number | true;
    showSecondaryControls(): boolean;
    isSortable(): boolean;
    totalSelectedCount(): number;
    headerOffset(): number | null;
}, {
    /**
     * Processes the results with searchFor, filterItems, and/or sortItems.
     * Skipped when isServerSide is true because results are pre-processed.
     * @returns {Promise<void>}
     */
    processResults(): Promise<void>;
    /**
     * Filters the list of `items` based on options selected in the `filters` object
     * @param {array} items A list of items to filter.
     * @returns list of items filtered by the applied filters
     */
    filterItems(items: any[]): any;
    /**
     * Sorts a list of items based on options selected in the `sorts` object
     * @param {array} items A list of items to sort.
     * @returns list of items sorted according to the sort term.
     */
    sortItems(items: any[]): any;
    change({ trigger }?: {
        trigger?: string | undefined;
    }): void;
    /**
     * Clear search term and reset results to their initial state
     */
    clearSearchTerm(): Promise<void>;
    /**
     * Resets the results to their initial state on page load
     */
    reset(): void;
    onSearchTermChange(): void;
    /**
     * Event handler for when the user:
     *  - clicks the Search button
     *  - presses the enter key while focused on the search input
     * Calls a method in Filters that triggers `this.onFilter`. This is necessary
     * in order to persist the filters in local storage, which is handled internally
     * by Filters.
     */
    onSearch(): void;
    /**
     * Event handler for when the user:
     *  - clicks the Apply button
     *  - clicks the Search button (from `this.onSearch`)
     *  - presses the enter key while focused on the search input (from `this.onSearch`)
     * @see: SELL-350
     * @param {object} [options] - optional parameters
     * @param {string} [options.trigger] - what caused the changes
     * @returns {Promise<void>}
     */
    onFilter({ trigger }?: {
        trigger?: string | undefined;
    }): Promise<void>;
    onFiltersToggleClick(): void;
    /**
     * Extend the dropdown list so it does not shift when
     * the options drawer is open
     */
    onSortToggle(): void;
    /**
     * Executes any side-effects when the sort `term` is changed
     * Always fires `change` automatically.
     * @param {string} term The updated sort term
     */
    onSort(term: string): void;
    /**
     * Sets current page for the Paginator.
     * @param {Object} data
     * @param {number} data.pageNumber - the page number
     * @param {boolean} data.forceChange - flag to force the change
     */
    setPage({ pageNumber, forceChange }?: {
        pageNumber: number;
        forceChange: boolean;
    }): void;
    /**
     * Set the scroll position to the top of the list view.
     */
    scrollToTop(): void;
    onPaginateSetPage(pageNumber: any): void;
    /**
     * Selects or deselects all items on a page
     */
    onSelectPage(value: any): void;
    selectAll(): void;
    /**
     * Selects one item
     */
    onSelectItem({ item, value }: {
        item: any;
        value: any;
    }): void;
    /**
     * Clears current selected items
     */
    clearSelected(): void;
    selectItems(items: any): any;
}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "change:filter" | "change:page" | "change:search" | "change:sort" | "change:reset" | "filters-toggle-click" | "select-all" | "deselect-all" | "update-filters" | "updateResults")[], "change" | "change:filter" | "change:page" | "change:search" | "change:sort" | "change:reset" | "filters-toggle-click" | "select-all" | "deselect-all" | "update-filters" | "updateResults", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    /**
     * Hide the '{number} of {total} selected' text for bulk actions
     */
    hideNumberOfTotalSelected: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Hide the Select All checkbox for bulk actions
     */
    hideSelectAll: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Text to render in EmptyState component if there are no results
     */
    emptyStateText: {
        type: StringConstructor;
        default: string;
    };
    filterSchema: {
        type: ArrayConstructor;
        default: () => never[];
    };
    /**
     * Make search fuzzy. Only for client side search.
     */
    fuzzySearch: {
        type: BooleanConstructor;
        default: boolean;
    };
    hideTotal: BooleanConstructor;
    initialPage: {
        type: NumberConstructor;
        default: undefined;
    };
    /**
     * Can items on the page be selected for bulk actions
     */
    isSelectable: BooleanConstructor;
    /**
     * For loading data already paginated, filtered (including search), and sorted from a backend.
     * Defining this prop will disable the built-in search, filtering, sorting and pagination.
     * You will instead need to use the available events (`@change`, and `@change:` prefixed)
     * to know when to request new pages from your backend.
     * This requires providing `totalItemCount`.
     * Use the loading prop to indicate when data is being loaded.
     */
    isServerSide: BooleanConstructor;
    /**
     * The data for each row. Used in this file as this.internalItems (a copy) to allow mutation;
     */
    items: {
        type: ArrayConstructor;
        default: () => never[];
    };
    /**
     * Default field to track selected items by
     */
    itemTrackBy: {
        type: StringConstructor;
        default: string;
    };
    loading: BooleanConstructor;
    pageSize: {
        type: NumberConstructor;
        default: number;
    };
    searchSchema: {
        type: ObjectConstructor;
        default: () => {};
    };
    sortLabel: {
        type: StringConstructor;
        default: () => any;
    };
    sortOnLoad: BooleanConstructor;
    sorts: {
        type: ObjectConstructor;
        default: () => {};
    };
    /**
     * Total number of unpaginated results
     * Required when `isServerSide` is `true`
     */
    totalItemCount: {
        type: NumberConstructor;
        default: undefined;
    };
    /**
     * Validation schema function that returns an object
     */
    validationSchema: {
        type: FunctionConstructor;
        default: () => () => undefined;
    };
    /**
     * Whether to disable the sticky filters
     * if disabled, the following will happen
     * 1. pre-selected value(s) can be added to
     * the filter component's attributes to overwrite the sticky filters
     * 2. users will not have sticky filters on the page
     */
    disablePersistency: BooleanConstructor;
    /**
     * Whether to disable the ability of saving 'show-filters'
     * in local storage
     */
    disableShowFilter: BooleanConstructor;
    /**
     * Whether to disable the stickiness of the header.
     * Default is false. When true, neither the list headers nor
     * the bulk actions (when applicable) will be sticky.
     */
    disableStickyHeader: BooleanConstructor;
    /**
     * Whether to expand the filters section by default on load.
     */
    showFiltersOnLoad: BooleanConstructor;
    /**
     * Do not use the LoadingManager, and instead render the default slot as passed
     */
    disableLoader: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * Override the header offset used to position the sticky header
     */
    stickyHeaderOffset: {
        type: NumberConstructor;
        default: null;
    };
    /**
     * Prevent bulk actions dropdown from rendering
     */
    hideBulkActionOptions: {
        type: BooleanConstructor;
        default: boolean;
    };
    /**
     * If initial search term is provided, the list will be filtered on load.
     */
    initialSearchTerm: {
        type: StringConstructor;
        default: string;
    };
    /**
     * Function that determines whether the item checkbox is disabled or not (default: false)
     */
    isItemDisabled: {
        type: FunctionConstructor;
        default: () => boolean;
    };
}>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
    "onChange:filter"?: ((...args: any[]) => any) | undefined;
    "onChange:page"?: ((...args: any[]) => any) | undefined;
    "onChange:search"?: ((...args: any[]) => any) | undefined;
    "onChange:sort"?: ((...args: any[]) => any) | undefined;
    "onChange:reset"?: ((...args: any[]) => any) | undefined;
    "onFilters-toggle-click"?: ((...args: any[]) => any) | undefined;
    "onSelect-all"?: ((...args: any[]) => any) | undefined;
    "onDeselect-all"?: ((...args: any[]) => any) | undefined;
    "onUpdate-filters"?: ((...args: any[]) => any) | undefined;
    onUpdateResults?: ((...args: any[]) => any) | undefined;
}>, {
    pageSize: number;
    isSelectable: boolean;
    emptyStateText: string;
    items: unknown[];
    loading: boolean;
    disablePersistency: boolean;
    validationSchema: Function;
    hideBulkActionOptions: boolean;
    hideNumberOfTotalSelected: boolean;
    hideTotal: boolean;
    isServerSide: boolean;
    sortOnLoad: boolean;
    disableShowFilter: boolean;
    disableStickyHeader: boolean;
    showFiltersOnLoad: boolean;
    hideSelectAll: boolean;
    filterSchema: unknown[];
    fuzzySearch: boolean;
    initialPage: number;
    itemTrackBy: string;
    searchSchema: Record<string, any>;
    sortLabel: string;
    sorts: Record<string, any>;
    totalItemCount: number;
    disableLoader: boolean;
    stickyHeaderOffset: number;
    initialSearchTerm: string;
    isItemDisabled: Function;
}, {}, {
    BulkActions: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        allowSelectAll: BooleanConstructor;
        isAllPageChecked: BooleanConstructor;
        isSomePageChecked: BooleanConstructor;
        hideBulkActionOptions: BooleanConstructor;
        hideNumberOfTotalSelected: BooleanConstructor;
        totalCount: {
            type: NumberConstructor;
            default: number;
        };
        totalSelectedCount: {
            type: NumberConstructor;
            default: number;
        };
    }>, {}, {
        selectAllText: any;
    }, {
        clearSelectedText(): any;
        showSelectAll(): boolean;
        numberOfTotalSelectedText(): any;
        selectAllCountText(): any;
        numItemsSelectedText(): any;
    }, {
        onSelectPage(value: any): void;
        selectAll(): void;
        clearSelected(): void;
    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change:select-current" | "change:select-all" | "change:clear-selected")[], "change:select-current" | "change:select-all" | "change:clear-selected", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        allowSelectAll: BooleanConstructor;
        isAllPageChecked: BooleanConstructor;
        isSomePageChecked: BooleanConstructor;
        hideBulkActionOptions: BooleanConstructor;
        hideNumberOfTotalSelected: BooleanConstructor;
        totalCount: {
            type: NumberConstructor;
            default: number;
        };
        totalSelectedCount: {
            type: NumberConstructor;
            default: number;
        };
    }>> & Readonly<{
        "onChange:select-current"?: ((...args: any[]) => any) | undefined;
        "onChange:select-all"?: ((...args: any[]) => any) | undefined;
        "onChange:clear-selected"?: ((...args: any[]) => any) | undefined;
    }>, {
        allowSelectAll: boolean;
        isAllPageChecked: boolean;
        isSomePageChecked: boolean;
        hideBulkActionOptions: boolean;
        hideNumberOfTotalSelected: boolean;
        totalCount: number;
        totalSelectedCount: number;
    }, {}, {
        'll-button': {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                color: "blue" | "red";
                icon: boolean;
                href: string;
                secondary: boolean;
                iconLabel: boolean;
                tertiary: boolean;
                inline: boolean;
                to: import("vue-router").RouteLocationRaw;
                isLoading: boolean;
                disabled: boolean;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
                color: "blue" | "red";
                icon: boolean;
                href: string;
                secondary: boolean;
                iconLabel: boolean;
                tertiary: boolean;
                inline: boolean;
                to: import("vue-router").RouteLocationRaw;
                isLoading: boolean;
                disabled: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            color: "blue" | "red";
            icon: boolean;
            href: string;
            secondary: boolean;
            iconLabel: boolean;
            tertiary: boolean;
            inline: boolean;
            to: import("vue-router").RouteLocationRaw;
            isLoading: boolean;
            disabled: boolean;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            };
        });
        'll-checkbox': {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
                "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
                "update:checked": (value: boolean | (string | number)[]) => any;
            }, import("vue").PublicProps, {
                id: string;
                label: string;
                disabled: boolean;
                value: string | number;
                modelValue: boolean | Array<string | number>;
                hasError: boolean;
                errorText: string;
                hintText: string;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
                "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
            }>, {}, {}, {}, {}, {
                id: string;
                label: string;
                disabled: boolean;
                value: string | number;
                modelValue: boolean | Array<string | number>;
                hasError: boolean;
                errorText: string;
                hintText: string;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
            "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            "update:checked": (value: boolean | (string | number)[]) => any;
        }, string, {
            id: string;
            label: string;
            disabled: boolean;
            value: string | number;
            modelValue: boolean | Array<string | number>;
            hasError: boolean;
            errorText: string;
            hintText: string;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            } & {
                hint?: (props: {}) => any;
            };
        });
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Filters: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        disableApply: BooleanConstructor;
        disableClear: BooleanConstructor;
        disablePersistency: BooleanConstructor;
        schema: {
            type: ArrayConstructor;
            default: () => never[];
        };
        validationSchema: {
            type: FunctionConstructor;
            default: () => () => undefined;
        };
    }>, {
        validation: import("vue").Ref<any, any>;
        validationValues: import("vue").Ref<{}, {}>;
        initValidation: () => void;
    }, {
        applyText: any;
        clearText: any;
        filters: {};
        filterValues: {};
        forceRenderCount: number;
    }, {}, {
        initFilterValues(): void;
        applyFilters({ trigger }?: {
            trigger?: string | undefined;
        }): Promise<void>;
        resetFilters(): void;
        getDefaultFilterValues(): unknown;
        setFilterValues(newValues: any): void;
        updateValidationValues(): void;
        onChange(filter: any, filterValues: any, filterIndex: any): void;
        onSelectInput(newValue: any, filter: any, filterIndex: any): void;
        getPersistentFilterValues(): any;
        persistFilterValues(newValues: object): void;
    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("reset" | "submit" | "change")[], "reset" | "submit" | "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        disableApply: BooleanConstructor;
        disableClear: BooleanConstructor;
        disablePersistency: BooleanConstructor;
        schema: {
            type: ArrayConstructor;
            default: () => never[];
        };
        validationSchema: {
            type: FunctionConstructor;
            default: () => () => undefined;
        };
    }>> & Readonly<{
        onChange?: ((...args: any[]) => any) | undefined;
        onReset?: ((...args: any[]) => any) | undefined;
        onSubmit?: ((...args: any[]) => any) | undefined;
    }>, {
        schema: unknown[];
        disableApply: boolean;
        disableClear: boolean;
        disablePersistency: boolean;
        validationSchema: Function;
    }, {}, {
        'll-button': {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                color: "blue" | "red";
                icon: boolean;
                href: string;
                secondary: boolean;
                iconLabel: boolean;
                tertiary: boolean;
                inline: boolean;
                to: import("vue-router").RouteLocationRaw;
                isLoading: boolean;
                disabled: boolean;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
                color: "blue" | "red";
                icon: boolean;
                href: string;
                secondary: boolean;
                iconLabel: boolean;
                tertiary: boolean;
                inline: boolean;
                to: import("vue-router").RouteLocationRaw;
                isLoading: boolean;
                disabled: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            color: "blue" | "red";
            icon: boolean;
            href: string;
            secondary: boolean;
            iconLabel: boolean;
            tertiary: boolean;
            inline: boolean;
            to: import("vue-router").RouteLocationRaw;
            isLoading: boolean;
            disabled: boolean;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            };
        });
        'll-checkbox': {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
                "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
                "update:checked": (value: boolean | (string | number)[]) => any;
            }, import("vue").PublicProps, {
                id: string;
                label: string;
                disabled: boolean;
                value: string | number;
                modelValue: boolean | Array<string | number>;
                hasError: boolean;
                errorText: string;
                hintText: string;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
                "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
            }>, {}, {}, {}, {}, {
                id: string;
                label: string;
                disabled: boolean;
                value: string | number;
                modelValue: boolean | Array<string | number>;
                hasError: boolean;
                errorText: string;
                hintText: string;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
            "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            "update:checked": (value: boolean | (string | number)[]) => any;
        }, string, {
            id: string;
            label: string;
            disabled: boolean;
            value: string | number;
            modelValue: boolean | Array<string | number>;
            hasError: boolean;
            errorText: string;
            hintText: string;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default?: (props: {}) => any;
            } & {
                hint?: (props: {}) => any;
            };
        });
        'll-input': {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Input.vue").InputProps> & Readonly<{
                onFocus?: ((evt: Event) => any) | undefined;
                onBlur?: ((evt: Event) => any) | undefined;
                onChange?: ((v: string | number) => any) | undefined;
                "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
            }>, {
                inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
                focus: (evt: Event) => any;
                blur: (evt: Event) => any;
                change: (v: string | number) => any;
                "update:model-value": (v: string | number) => any;
            }, import("vue").PublicProps, {
                type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
                value: string | number | null;
                modelValue: string | number;
                placeholder: string;
                autocomplete: string;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./Input.vue").InputProps> & Readonly<{
                onFocus?: ((evt: Event) => any) | undefined;
                onBlur?: ((evt: Event) => any) | undefined;
                onChange?: ((v: string | number) => any) | undefined;
                "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
            }>, {
                inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
            }, {}, {}, {}, {
                type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
                value: string | number | null;
                modelValue: string | number;
                placeholder: string;
                autocomplete: string;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./Input.vue").InputProps> & Readonly<{
            onFocus?: ((evt: Event) => any) | undefined;
            onBlur?: ((evt: Event) => any) | undefined;
            onChange?: ((v: string | number) => any) | undefined;
            "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
        }>, {
            inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            focus: (evt: Event) => any;
            blur: (evt: Event) => any;
            change: (v: string | number) => any;
            "update:model-value": (v: string | number) => any;
        }, string, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            value: string | number | null;
            modelValue: string | number;
            placeholder: string;
            autocomplete: string;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                prepend?: (props: {}) => any;
            } & {
                append?: (props: {}) => any;
            } & {
                hint?: (props: {}) => any;
            };
        });
        'll-input-options': {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./InputOptions.vue").InputOptionsProps> & Readonly<{
                onChange?: ((v: {
                    value?: string;
                    option?: any;
                    isValueChange: boolean;
                    type: "input" | "select";
                }) => any) | undefined;
                "onUpdate:model-value"?: ((v: {
                    value?: string;
                    option?: any;
                    isValueChange: boolean;
                    type: "input" | "select";
                }) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
                change: (v: {
                    value?: string;
                    option?: any;
                    isValueChange: boolean;
                    type: "input" | "select";
                }) => any;
                "update:model-value": (v: {
                    value?: string;
                    option?: any;
                    isValueChange: boolean;
                    type: "input" | "select";
                }) => any;
            }, import("vue").PublicProps, {
                type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
                options: any[];
                modelValue: {
                    value: string;
                    option?: any;
                };
                placeholder: string;
                trackBy: string;
                displayBy: string;
                noTruncate: boolean;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./InputOptions.vue").InputOptionsProps> & Readonly<{
                onChange?: ((v: {
                    value?: string;
                    option?: any;
                    isValueChange: boolean;
                    type: "input" | "select";
                }) => any) | undefined;
                "onUpdate:model-value"?: ((v: {
                    value?: string;
                    option?: any;
                    isValueChange: boolean;
                    type: "input" | "select";
                }) => any) | undefined;
            }>, {}, {}, {}, {}, {
                type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
                options: any[];
                modelValue: {
                    value: string;
                    option?: any;
                };
                placeholder: string;
                trackBy: string;
                displayBy: string;
                noTruncate: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./InputOptions.vue").InputOptionsProps> & Readonly<{
            onChange?: ((v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any) | undefined;
            "onUpdate:model-value"?: ((v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            change: (v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any;
            "update:model-value": (v: {
                value?: string;
                option?: any;
                isValueChange: boolean;
                type: "input" | "select";
            }) => any;
        }, string, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            options: any[];
            modelValue: {
                value: string;
                option?: any;
            };
            placeholder: string;
            trackBy: string;
            displayBy: string;
            noTruncate: boolean;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                default: (props: {
                    fieldId: string;
                }) => void;
                hint: () => unknown;
            };
        });
        'll-radio': import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            checked: {
                type: (StringConstructor | NumberConstructor)[];
                default: undefined;
            };
            modelValue: {
                type: (StringConstructor | NumberConstructor | null)[];
                default: null;
                validator(value: unknown): true;
            };
            hasError: BooleanConstructor;
            id: {
                type: StringConstructor;
                required: true;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
        }>, {
            classes: Record<string, string>;
        }, {}, {
            internalValue: {
                get(): string | number | undefined;
                set(value: any): void;
            };
        }, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:checked"[], "update:checked", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            checked: {
                type: (StringConstructor | NumberConstructor)[];
                default: undefined;
            };
            modelValue: {
                type: (StringConstructor | NumberConstructor | null)[];
                default: null;
                validator(value: unknown): true;
            };
            hasError: BooleanConstructor;
            id: {
                type: StringConstructor;
                required: true;
            };
            label: {
                type: StringConstructor;
                default: string;
            };
        }>> & Readonly<{
            "onUpdate:checked"?: ((...args: any[]) => any) | undefined;
        }>, {
            label: string;
            modelValue: string | number | null;
            checked: string | number;
            hasError: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        'll-select': {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Select.vue").SelectProps> & Readonly<{
                onClear?: (() => any) | undefined;
                onAdd?: ((optionAdded: any) => any) | undefined;
                onRemove?: ((optionRemoved: any, index: number) => any) | undefined;
                "onUpdate:model-value"?: ((selectedOptions: any) => any) | undefined;
                onOpened?: (() => any) | undefined;
                onClosed?: ((selectedOptions: any) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
                clear: () => any;
                add: (optionAdded: any) => any;
                remove: (optionRemoved: any, index: number) => any;
                "update:model-value": (selectedOptions: any) => any;
                opened: () => any;
                closed: (selectedOptions: any) => any;
            }, import("vue").PublicProps, {
                name: string;
                error: string;
                icon: string | boolean;
                value: any | null;
                options: any[] | readonly any[];
                modelValue: any;
                hint: string;
                placeholder: string;
                trackBy: string;
                preventEmpty: boolean;
                allowEmpty: string | boolean | null;
                displayBy: string;
                searchBy: string[];
                lazy: () => any[];
                hideSearch: boolean;
                searchable: string | boolean | null;
                preserveSearchTerm: boolean;
                disableFiltering: boolean;
                single: boolean;
                noTruncate: boolean;
                loading: boolean;
                searchLoading: boolean;
                selectItemType: string;
                hideCheck: boolean;
                searchPlaceholder: string;
                onSearch: (searchTerm: string) => Promise<void> | void;
                useFuzzySearch: boolean;
                menuPlacement: import("@floating-ui/vue").Placement;
                enableTeleport: boolean;
                teleportTo: string | HTMLElement;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./Select.vue").SelectProps> & Readonly<{
                onClear?: (() => any) | undefined;
                onAdd?: ((optionAdded: any) => any) | undefined;
                onRemove?: ((optionRemoved: any, index: number) => any) | undefined;
                "onUpdate:model-value"?: ((selectedOptions: any) => any) | undefined;
                onOpened?: (() => any) | undefined;
                onClosed?: ((selectedOptions: any) => any) | undefined;
            }>, {}, {}, {}, {}, {
                name: string;
                error: string;
                icon: string | boolean;
                value: any | null;
                options: any[] | readonly any[];
                modelValue: any;
                hint: string;
                placeholder: string;
                trackBy: string;
                preventEmpty: boolean;
                allowEmpty: string | boolean | null;
                displayBy: string;
                searchBy: string[];
                lazy: () => any[];
                hideSearch: boolean;
                searchable: string | boolean | null;
                preserveSearchTerm: boolean;
                disableFiltering: boolean;
                single: boolean;
                noTruncate: boolean;
                loading: boolean;
                searchLoading: boolean;
                selectItemType: string;
                hideCheck: boolean;
                searchPlaceholder: string;
                onSearch: (searchTerm: string) => Promise<void> | void;
                useFuzzySearch: boolean;
                menuPlacement: import("@floating-ui/vue").Placement;
                enableTeleport: boolean;
                teleportTo: string | HTMLElement;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./Select.vue").SelectProps> & Readonly<{
            onClear?: (() => any) | undefined;
            onAdd?: ((optionAdded: any) => any) | undefined;
            onRemove?: ((optionRemoved: any, index: number) => any) | undefined;
            "onUpdate:model-value"?: ((selectedOptions: any) => any) | undefined;
            onOpened?: (() => any) | undefined;
            onClosed?: ((selectedOptions: any) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            clear: () => any;
            add: (optionAdded: any) => any;
            remove: (optionRemoved: any, index: number) => any;
            "update:model-value": (selectedOptions: any) => any;
            opened: () => any;
            closed: (selectedOptions: any) => any;
        }, string, {
            name: string;
            error: string;
            icon: string | boolean;
            value: any | null;
            options: any[] | readonly any[];
            modelValue: any;
            hint: string;
            placeholder: string;
            trackBy: string;
            preventEmpty: boolean;
            allowEmpty: string | boolean | null;
            displayBy: string;
            searchBy: string[];
            lazy: () => any[];
            hideSearch: boolean;
            searchable: string | boolean | null;
            preserveSearchTerm: boolean;
            disableFiltering: boolean;
            single: boolean;
            noTruncate: boolean;
            loading: boolean;
            searchLoading: boolean;
            selectItemType: string;
            hideCheck: boolean;
            searchPlaceholder: string;
            onSearch: (searchTerm: string) => Promise<void> | void;
            useFuzzySearch: boolean;
            menuPlacement: import("@floating-ui/vue").Placement;
            enableTeleport: boolean;
            teleportTo: string | HTMLElement;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                selected(props: {
                    option: any;
                    onRemove: () => void;
                    chipSelectedClass: string;
                }): unknown;
                option(props: {
                    option: any;
                }): unknown;
                'no-options'(): unknown;
                hint(): unknown;
            };
        });
        DatePicker: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./_internal/components/DatePicker/DatePicker.types").DatePickerProps> & Readonly<{
                onBlur?: (() => any) | undefined;
                "onUpdate:model-value"?: ((date: string | number | Date) => any) | undefined;
            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
                blur: () => any;
                "update:model-value": (date: string | number | Date) => any;
            }, import("vue").PublicProps, {
                id: string;
                name: string;
                label: string;
                disabled: boolean;
                mode: "date" | "dateTime" | "time";
                modelValue: string;
                errorText: string;
                hintText: string;
                format: string;
                addBottomSpace: boolean;
                placeholder: string;
                timeZone: string;
                enableTeleport: boolean;
                availableDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
                disabledDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
                hideClearButton: boolean;
                isInputReadonly: boolean;
                maxDate: Date;
                minDate: Date;
                maxPage: {
                    month: number;
                    year: number;
                };
                minPage: {
                    month: number;
                    year: number;
                };
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./_internal/components/DatePicker/DatePicker.types").DatePickerProps> & Readonly<{
                onBlur?: (() => any) | undefined;
                "onUpdate:model-value"?: ((date: string | number | Date) => any) | undefined;
            }>, {}, {}, {}, {}, {
                id: string;
                name: string;
                label: string;
                disabled: boolean;
                mode: "date" | "dateTime" | "time";
                modelValue: string;
                errorText: string;
                hintText: string;
                format: string;
                addBottomSpace: boolean;
                placeholder: string;
                timeZone: string;
                enableTeleport: boolean;
                availableDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
                disabledDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
                hideClearButton: boolean;
                isInputReadonly: boolean;
                maxDate: Date;
                minDate: Date;
                maxPage: {
                    month: number;
                    year: number;
                };
                minPage: {
                    month: number;
                    year: number;
                };
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./_internal/components/DatePicker/DatePicker.types").DatePickerProps> & Readonly<{
            onBlur?: (() => any) | undefined;
            "onUpdate:model-value"?: ((date: string | number | Date) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            blur: () => any;
            "update:model-value": (date: string | number | Date) => any;
        }, string, {
            id: string;
            name: string;
            label: string;
            disabled: boolean;
            mode: "date" | "dateTime" | "time";
            modelValue: string;
            errorText: string;
            hintText: string;
            format: string;
            addBottomSpace: boolean;
            placeholder: string;
            timeZone: string;
            enableTeleport: boolean;
            availableDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
            disabledDates: import("v-calendar/dist/types/src/utils/date/range.js").DateRangeSource[];
            hideClearButton: boolean;
            isInputReadonly: boolean;
            maxDate: Date;
            minDate: Date;
            maxPage: {
                month: number;
                year: number;
            };
            minPage: {
                month: number;
                year: number;
            };
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: {
                hint?: (props: {}) => any;
            };
        });
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Paginate: import("vue").DefineComponent<import("./Paginate.vue").PaginateProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        "set-page": (pageNumber: number) => any;
    }, string, import("vue").PublicProps, Readonly<import("./Paginate.vue").PaginateProps> & Readonly<{
        "onSet-page"?: ((pageNumber: number) => any) | undefined;
    }>, {
        currentPage: number;
        pageSize: number;
        variant: "standard" | "stats";
        listLength: number;
        isNextDisabled: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
    LoadingManager: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        emptyStateText: {
            type: StringConstructor;
            default: string;
        };
        loading: BooleanConstructor;
        results: {
            type: ArrayConstructor;
            default: () => never[];
        };
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        emptyStateText: {
            type: StringConstructor;
            default: string;
        };
        loading: BooleanConstructor;
        results: {
            type: ArrayConstructor;
            default: () => never[];
        };
    }>> & Readonly<{}>, {
        emptyStateText: string;
        loading: boolean;
        results: unknown[];
    }, {}, {
        EmptyState: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./EmptyState.vue").EmptyStateProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
                image: {
                    alt?: string;
                    src: string;
                };
                title: string;
                text: string;
                vignette: import("./_internal/components/Illustration/Illustration.models").VignetteNames;
                subtitle: string;
                footnote: string;
                vignetteSize: number;
            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import("./EmptyState.vue").EmptyStateProps> & Readonly<{}>, {}, {}, {}, {}, {
                image: {
                    alt?: string;
                    src: string;
                };
                title: string;
                text: string;
                vignette: import("./_internal/components/Illustration/Illustration.models").VignetteNames;
                subtitle: string;
                footnote: string;
                vignetteSize: number;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<import("./EmptyState.vue").EmptyStateProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
            image: {
                alt?: string;
                src: string;
            };
            title: string;
            text: string;
            vignette: import("./_internal/components/Illustration/Illustration.models").VignetteNames;
            subtitle: string;
            footnote: string;
            vignetteSize: number;
        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
            $slots: import("./EmptyState.vue").EmptyStateSlots;
        });
        Loading: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Badge: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Badge.vue").BadgeProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
            color: "red" | "blue";
            max: number | string;
            animate: boolean;
            content: number | string;
            variant: "dot" | "standard";
            position: "top-right" | "inline";
            isDisabled: boolean;
            offset: {
                top?: number;
                right?: number;
            };
            showZero: boolean;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Badge.vue").BadgeProps> & Readonly<{}>, {}, {}, {}, {}, {
            color: "red" | "blue";
            max: number | string;
            animate: boolean;
            content: number | string;
            variant: "dot" | "standard";
            position: "top-right" | "inline";
            isDisabled: boolean;
            offset: {
                top?: number;
                right?: number;
            };
            showZero: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Badge.vue").BadgeProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        color: "red" | "blue";
        max: number | string;
        animate: boolean;
        content: number | string;
        variant: "dot" | "standard";
        position: "top-right" | "inline";
        isDisabled: boolean;
        offset: {
            top?: number;
            right?: number;
        };
        showZero: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {}) => any;
        };
    });
    Button: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
            color: "blue" | "red";
            icon: boolean;
            href: string;
            secondary: boolean;
            iconLabel: boolean;
            tertiary: boolean;
            inline: boolean;
            to: import("vue-router").RouteLocationRaw;
            isLoading: boolean;
            disabled: boolean;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
            color: "blue" | "red";
            icon: boolean;
            href: string;
            secondary: boolean;
            iconLabel: boolean;
            tertiary: boolean;
            inline: boolean;
            to: import("vue-router").RouteLocationRaw;
            isLoading: boolean;
            disabled: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Button.vue").ButtonProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
        color: "blue" | "red";
        icon: boolean;
        href: string;
        secondary: boolean;
        iconLabel: boolean;
        tertiary: boolean;
        inline: boolean;
        to: import("vue-router").RouteLocationRaw;
        isLoading: boolean;
        disabled: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {}) => any;
        };
    });
    Icon: import("vue").DefineComponent<import("./Icon.vue").IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./Icon.vue").IconProps> & Readonly<{}>, {
        id: string;
        title: string;
        size: import("./_internal/components/Icon/Icon.types").IconSize;
        staticPath: string;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
    Dropdown: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Dropdown.vue").DropdownProps> & Readonly<{
            onDismiss?: (() => any) | undefined;
            onToggle?: ((isActive: boolean) => any) | undefined;
        }>, {
            isActive: import("vue").ComputedRef<boolean>;
            toggle: () => Promise<void>;
            dismiss: (event?: Event) => void;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            dismiss: () => any;
            toggle: (isActive: boolean) => any;
        }, import("vue").PublicProps, {
            label: string;
            offset: import("./Dropdown.vue").DropdownOffset;
            align: "left" | "right";
            closeManually: boolean;
            reattach: boolean;
            contentClass: string | string[];
            fluidContent: boolean;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Dropdown.vue").DropdownProps> & Readonly<{
            onDismiss?: (() => any) | undefined;
            onToggle?: ((isActive: boolean) => any) | undefined;
        }>, {
            isActive: import("vue").ComputedRef<boolean>;
            toggle: () => Promise<void>;
            dismiss: (event?: Event) => void;
        }, {}, {}, {}, {
            label: string;
            offset: import("./Dropdown.vue").DropdownOffset;
            align: "left" | "right";
            closeManually: boolean;
            reattach: boolean;
            contentClass: string | string[];
            fluidContent: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Dropdown.vue").DropdownProps> & Readonly<{
        onDismiss?: (() => any) | undefined;
        onToggle?: ((isActive: boolean) => any) | undefined;
    }>, {
        isActive: import("vue").ComputedRef<boolean>;
        toggle: () => Promise<void>;
        dismiss: (event?: Event) => void;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
        dismiss: () => any;
        toggle: (isActive: boolean) => any;
    }, string, {
        label: string;
        offset: import("./Dropdown.vue").DropdownOffset;
        align: "left" | "right";
        closeManually: boolean;
        reattach: boolean;
        contentClass: string | string[];
        fluidContent: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            toggle?: (props: {
                isActive: boolean;
                toggle: () => Promise<void>;
            }) => any;
        } & {
            default?: (props: {
                dismiss: (event?: Event) => void;
                isActive: boolean;
            }) => any;
        };
    });
    Expand: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Expand.vue").ExpandProps> & Readonly<{
            "onAfter-expand"?: (() => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            "after-expand": () => any;
        }, import("vue").PublicProps, {
            transitionName: string;
            is: import("./Expand.vue").ExpandOuterElement;
            isExpanded: boolean;
            isLazy: boolean;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Expand.vue").ExpandProps> & Readonly<{
            "onAfter-expand"?: (() => any) | undefined;
        }>, {}, {}, {}, {}, {
            transitionName: string;
            is: import("./Expand.vue").ExpandOuterElement;
            isExpanded: boolean;
            isLazy: boolean;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Expand.vue").ExpandProps> & Readonly<{
        "onAfter-expand"?: (() => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        "after-expand": () => any;
    }, string, {
        transitionName: string;
        is: import("./Expand.vue").ExpandOuterElement;
        isExpanded: boolean;
        isLazy: boolean;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {}) => any;
        } & {
            default?: (props: {}) => any;
        };
    });
    Checkbox: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
            "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            "update:checked": (value: boolean | (string | number)[]) => any;
        }, import("vue").PublicProps, {
            id: string;
            label: string;
            disabled: boolean;
            value: string | number;
            modelValue: boolean | Array<string | number>;
            hasError: boolean;
            errorText: string;
            hintText: string;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
            "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
        }>, {}, {}, {}, {}, {
            id: string;
            label: string;
            disabled: boolean;
            value: string | number;
            modelValue: boolean | Array<string | number>;
            hasError: boolean;
            errorText: string;
            hintText: string;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Checkbox.vue").CheckboxProps> & Readonly<{
        "onUpdate:checked"?: ((value: boolean | (string | number)[]) => any) | undefined;
    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        "update:checked": (value: boolean | (string | number)[]) => any;
    }, string, {
        id: string;
        label: string;
        disabled: boolean;
        value: string | number;
        modelValue: boolean | Array<string | number>;
        hasError: boolean;
        errorText: string;
        hintText: string;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            default?: (props: {}) => any;
        } & {
            hint?: (props: {}) => any;
        };
    });
    Input: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./Input.vue").InputProps> & Readonly<{
            onFocus?: ((evt: Event) => any) | undefined;
            onBlur?: ((evt: Event) => any) | undefined;
            onChange?: ((v: string | number) => any) | undefined;
            "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
        }>, {
            inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
            focus: (evt: Event) => any;
            blur: (evt: Event) => any;
            change: (v: string | number) => any;
            "update:model-value": (v: string | number) => any;
        }, import("vue").PublicProps, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            value: string | number | null;
            modelValue: string | number;
            placeholder: string;
            autocomplete: string;
        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import("./Input.vue").InputProps> & Readonly<{
            onFocus?: ((evt: Event) => any) | undefined;
            onBlur?: ((evt: Event) => any) | undefined;
            onChange?: ((v: string | number) => any) | undefined;
            "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
        }>, {
            inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
        }, {}, {}, {}, {
            type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
            value: string | number | null;
            modelValue: string | number;
            placeholder: string;
            autocomplete: string;
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<import("./Input.vue").InputProps> & Readonly<{
        onFocus?: ((evt: Event) => any) | undefined;
        onBlur?: ((evt: Event) => any) | undefined;
        onChange?: ((v: string | number) => any) | undefined;
        "onUpdate:model-value"?: ((v: string | number) => any) | undefined;
    }>, {
        inputEl: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
        focus: (evt: Event) => any;
        blur: (evt: Event) => any;
        change: (v: string | number) => any;
        "update:model-value": (v: string | number) => any;
    }, string, {
        type: string extends "button" | "checkbox" | "radio" | "submit" ? never : string;
        value: string | number | null;
        modelValue: string | number;
        placeholder: string;
        autocomplete: string;
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
        $slots: {
            prepend?: (props: {}) => any;
        } & {
            append?: (props: {}) => any;
        } & {
            hint?: (props: {}) => any;
        };
    });
}, {
    sticky: {
        mounted(el: any, binding: any): void;
        unmounted(el: any): void;
        updated(el: any, binding: any): void;
    };
}, string, import("vue").ComponentProvideOptions, true, {}, any>;