prismify-ui 0.1.0-alpha.1

package/dist/components/form/PfInputMenu/index.vue.d.ts

@@ -0,0 +1,1410 @@
+import { nextTick } from 'vue';
+import { PfSelectColor, PfSelectModelValue, PfSelectOption, PfSelectOptionAvatarConfig, PfSelectOptionGroups, PfSelectSize, PfSelectUi, PfSelectVariant } from '../PfSelect/index.vue';
+import { PfIconName } from '../../element/PfIcon/paths';
+export type PfInputMenuPrimitive = string | number | boolean;
+export interface PfInputMenuItemObject {
+    label?: string;
+    value?: unknown;
+    disabled?: boolean;
+    icon?: PfIconName;
+    imageSrc?: string;
+    imageAlt?: string;
+    avatar?: PfSelectOptionAvatarConfig;
+    chip?: PfSelectOption['chip'];
+    selectedIcon?: PfIconName | null;
+    type?: 'label' | 'separator' | 'item';
+    [key: string]: unknown;
+}
+export type PfInputMenuItem = PfInputMenuPrimitive | PfInputMenuItemObject;
+export type PfInputMenuItems = readonly PfInputMenuItem[] | readonly (readonly PfInputMenuItem[])[];
+export type PfInputMenuModelValue = unknown | unknown[] | undefined;
+export interface PfInputMenuUi extends PfSelectUi {
+    triggerRow?: string;
+    tags?: string;
+    tag?: string;
+    tagText?: string;
+    tagRemove?: string;
+    tagRemoveIcon?: string;
+    chevron?: string;
+}
+type __VLS_Props = {
+    id?: string;
+    name?: string;
+    form?: string;
+    items?: PfInputMenuItems;
+    modelValue?: PfInputMenuModelValue;
+    defaultValue?: PfInputMenuModelValue;
+    placeholder?: string;
+    multiple?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    highlight?: boolean;
+    color?: PfSelectColor;
+    variant?: PfSelectVariant;
+    size?: PfSelectSize;
+    valueKey?: string;
+    labelKey?: string;
+    descriptionKey?: string;
+    filterFields?: string[];
+    ignoreFilter?: boolean;
+    searchTerm?: string;
+    resetSearchTermOnBlur?: boolean;
+    resetSearchTermOnSelect?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    openOnFocus?: boolean;
+    openOnClick?: boolean;
+    clearable?: boolean;
+    menuGap?: number;
+    chevronIcon?: PfIconName;
+    selectedOptionIcon?: PfIconName | null;
+    leadingIcon?: PfIconName;
+    leadingAvatar?: PfSelectOptionAvatarConfig;
+    loading?: boolean;
+    loadingIcon?: PfIconName;
+    allowEmptyPanel?: boolean;
+    emptyText?: string;
+    animatedText?: boolean;
+    deleteIcon?: PfIconName;
+    by?: string | ((a: unknown, b: unknown) => boolean);
+    ui?: PfInputMenuUi;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        panelEmpty?(_: {}): any;
+    };
+    refs: {
+        selectRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly id?: string | undefined;
+                readonly modelValue?: PfSelectModelValue;
+                readonly defaultValue?: PfSelectModelValue;
+                readonly options?: readonly PfSelectOption[] | undefined;
+                readonly optionGroups?: PfSelectOptionGroups | undefined;
+                readonly optionGroupLabels?: readonly (string | undefined)[] | undefined;
+                readonly placeholder?: string | undefined;
+                readonly multiple?: boolean | undefined;
+                readonly listboxRows?: number | undefined;
+                readonly native?: boolean | undefined;
+                readonly name?: string | undefined;
+                readonly required?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly autocomplete?: string | undefined;
+                readonly autofocus?: boolean | undefined;
+                readonly form?: string | undefined;
+                readonly color?: PfSelectColor | undefined;
+                readonly variant?: PfSelectVariant | undefined;
+                readonly size?: PfSelectSize | undefined;
+                readonly highlight?: boolean | undefined;
+                readonly chevronIcon?: PfIconName | undefined;
+                readonly trailingIcon?: PfIconName | undefined;
+                readonly selectedOptionIcon?: (PfIconName | null) | undefined;
+                readonly leadingIcon?: PfIconName | undefined;
+                readonly leadingAvatar?: PfSelectOptionAvatarConfig | undefined;
+                readonly loading?: boolean | undefined;
+                readonly loadingIcon?: PfIconName | undefined;
+                readonly menuGap?: number | undefined;
+                readonly clearable?: boolean | undefined;
+                readonly clearOptionLabel?: string | undefined;
+                readonly defaultOpen?: boolean | undefined;
+                readonly allowEmptyPanel?: boolean | undefined;
+                readonly optionFilter?: ((index: number, option: PfSelectOption) => boolean) | undefined;
+                readonly emptyText?: string | undefined;
+                readonly focusTriggerAfterSingleSelect?: boolean | undefined;
+                readonly ui?: PfSelectUi | undefined;
+                readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+                readonly onChange?: ((event: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+                readonly "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                shellRef: HTMLDivElement;
+                triggerRef: HTMLDivElement;
+                selectRef: HTMLSelectElement;
+                panelRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: PfSelectModelValue) => void) & ((event: "update:menuOpen", value: boolean) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                id?: string;
+                modelValue?: PfSelectModelValue;
+                defaultValue?: PfSelectModelValue;
+                options?: readonly PfSelectOption[];
+                optionGroups?: PfSelectOptionGroups;
+                optionGroupLabels?: readonly (string | undefined)[];
+                placeholder?: string;
+                multiple?: boolean;
+                listboxRows?: number;
+                native?: boolean;
+                name?: string;
+                required?: boolean;
+                disabled?: boolean;
+                autocomplete?: string;
+                autofocus?: boolean;
+                form?: string;
+                color?: PfSelectColor;
+                variant?: PfSelectVariant;
+                size?: PfSelectSize;
+                highlight?: boolean;
+                chevronIcon?: PfIconName;
+                trailingIcon?: PfIconName;
+                selectedOptionIcon?: PfIconName | null;
+                leadingIcon?: PfIconName;
+                leadingAvatar?: PfSelectOptionAvatarConfig;
+                loading?: boolean;
+                loadingIcon?: PfIconName;
+                menuGap?: number;
+                clearable?: boolean;
+                clearOptionLabel?: string;
+                defaultOpen?: boolean;
+                allowEmptyPanel?: boolean;
+                optionFilter?: (index: number, option: PfSelectOption) => boolean;
+                emptyText?: string;
+                focusTriggerAfterSingleSelect?: boolean;
+                ui?: PfSelectUi;
+            }> & Readonly<{
+                onBlur?: ((event: FocusEvent) => any) | undefined;
+                onChange?: ((event: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+                "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+            }>, {
+                selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+                triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+                panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                open: () => void;
+                close: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: PfSelectModelValue) => any;
+                "update:menuOpen": (value: boolean) => any;
+            }, string, {
+                required: boolean;
+                loading: boolean;
+                color: PfSelectColor;
+                variant: PfSelectVariant;
+                disabled: boolean;
+                multiple: boolean;
+                autocomplete: string;
+                highlight: boolean;
+                native: boolean;
+                menuGap: number;
+                clearable: boolean;
+                allowEmptyPanel: boolean;
+                emptyText: string;
+                focusTriggerAfterSingleSelect: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            required: boolean;
+            loading: boolean;
+            color: PfSelectColor;
+            variant: PfSelectVariant;
+            disabled: boolean;
+            multiple: boolean;
+            autocomplete: string;
+            highlight: boolean;
+            native: boolean;
+            menuGap: number;
+            clearable: boolean;
+            allowEmptyPanel: boolean;
+            emptyText: string;
+            focusTriggerAfterSingleSelect: boolean;
+        }> & Omit<Readonly<{
+            id?: string;
+            modelValue?: PfSelectModelValue;
+            defaultValue?: PfSelectModelValue;
+            options?: readonly PfSelectOption[];
+            optionGroups?: PfSelectOptionGroups;
+            optionGroupLabels?: readonly (string | undefined)[];
+            placeholder?: string;
+            multiple?: boolean;
+            listboxRows?: number;
+            native?: boolean;
+            name?: string;
+            required?: boolean;
+            disabled?: boolean;
+            autocomplete?: string;
+            autofocus?: boolean;
+            form?: string;
+            color?: PfSelectColor;
+            variant?: PfSelectVariant;
+            size?: PfSelectSize;
+            highlight?: boolean;
+            chevronIcon?: PfIconName;
+            trailingIcon?: PfIconName;
+            selectedOptionIcon?: PfIconName | null;
+            leadingIcon?: PfIconName;
+            leadingAvatar?: PfSelectOptionAvatarConfig;
+            loading?: boolean;
+            loadingIcon?: PfIconName;
+            menuGap?: number;
+            clearable?: boolean;
+            clearOptionLabel?: string;
+            defaultOpen?: boolean;
+            allowEmptyPanel?: boolean;
+            optionFilter?: (index: number, option: PfSelectOption) => boolean;
+            emptyText?: string;
+            focusTriggerAfterSingleSelect?: boolean;
+            ui?: PfSelectUi;
+        }> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+            "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+        }>, "close" | "open" | "selectRef" | "triggerRef" | "panelRef" | ("required" | "loading" | "color" | "variant" | "disabled" | "multiple" | "autocomplete" | "highlight" | "native" | "menuGap" | "clearable" | "allowEmptyPanel" | "emptyText" | "focusTriggerAfterSingleSelect")> & import('vue').ShallowUnwrapRef<{
+            selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+            triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+            panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            open: () => void;
+            close: () => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                leading?(_: {}): any;
+                leading?(_: {}): any;
+                trigger?(_: {
+                    comboboxAttrs: Record<string, string | boolean | undefined>;
+                    togglePanel: () => void;
+                    openPanel: () => void;
+                    closePanel: () => void;
+                }): any;
+                panelTop?(_: {}): any;
+                panelEmpty?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+        inputComponentRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | undefined;
+                readonly id?: string | undefined;
+                readonly name?: string | undefined;
+                readonly type?: string | undefined;
+                readonly placeholder?: string | undefined;
+                readonly color?: import('../PfInput/index.vue').PfInputColor | undefined;
+                readonly variant?: import('../PfInput/index.vue').PfInputVariant | undefined;
+                readonly size?: "xs" | "sm" | "md" | "lg" | "xl" | undefined;
+                readonly required?: boolean | undefined;
+                readonly autocomplete?: string | undefined;
+                readonly autofocus?: boolean | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly highlight?: boolean | undefined;
+                readonly fixed?: boolean | undefined;
+                readonly animatedText?: boolean | undefined;
+                readonly ui?: import('../PfInput/index.vue').PfInputUi | undefined;
+                readonly icon?: PfIconName | undefined;
+                readonly avatar?: import('../../..').PfButtonAvatarProps | undefined;
+                readonly leading?: boolean | undefined;
+                readonly leadingIcon?: PfIconName | undefined;
+                readonly trailing?: boolean | undefined;
+                readonly trailingIcon?: PfIconName | undefined;
+                readonly loading?: boolean | undefined;
+                readonly loadingIcon?: PfIconName | undefined;
+                readonly maxlength?: number | undefined;
+                readonly minlength?: number | undefined;
+                readonly pattern?: string | undefined;
+                readonly list?: string | undefined;
+                readonly form?: string | undefined;
+                readonly enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send" | undefined;
+                readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+                readonly onChange?: ((event: Event) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                valueCellRef: HTMLDivElement;
+                inputRef: HTMLInputElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                modelValue?: string;
+            } & {
+                id?: string;
+                name?: string;
+                type?: string;
+                placeholder?: string;
+                color?: import('../PfInput/index.vue').PfInputColor;
+                variant?: import('../PfInput/index.vue').PfInputVariant;
+                size?: "xs" | "sm" | "md" | "lg" | "xl";
+                required?: boolean;
+                autocomplete?: string;
+                autofocus?: boolean;
+                disabled?: boolean;
+                readonly?: boolean;
+                highlight?: boolean;
+                fixed?: boolean;
+                animatedText?: boolean;
+                ui?: import('../PfInput/index.vue').PfInputUi;
+                icon?: PfIconName;
+                avatar?: import('../../..').PfButtonAvatarProps;
+                leading?: boolean;
+                leadingIcon?: PfIconName;
+                trailing?: boolean;
+                trailingIcon?: PfIconName;
+                loading?: boolean;
+                loadingIcon?: PfIconName;
+                maxlength?: number;
+                minlength?: number;
+                pattern?: string;
+                list?: string;
+                form?: string;
+                enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send";
+            }> & Readonly<{
+                onBlur?: ((event: FocusEvent) => any) | undefined;
+                onChange?: ((event: Event) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            }>, {
+                inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                blur: (event: FocusEvent) => any;
+                change: (event: Event) => any;
+                "update:modelValue": (value: string) => any;
+            }, string, {
+                fixed: boolean;
+                type: string;
+                loading: boolean;
+                color: import('../PfInput/index.vue').PfInputColor;
+                variant: import('../PfInput/index.vue').PfInputVariant;
+                disabled: boolean;
+                readonly: boolean;
+                autocomplete: string;
+                highlight: boolean;
+                animatedText: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            fixed: boolean;
+            type: string;
+            loading: boolean;
+            color: import('../PfInput/index.vue').PfInputColor;
+            variant: import('../PfInput/index.vue').PfInputVariant;
+            disabled: boolean;
+            readonly: boolean;
+            autocomplete: string;
+            highlight: boolean;
+            animatedText: boolean;
+        }> & Omit<Readonly<{
+            modelValue?: string;
+        } & {
+            id?: string;
+            name?: string;
+            type?: string;
+            placeholder?: string;
+            color?: import('../PfInput/index.vue').PfInputColor;
+            variant?: import('../PfInput/index.vue').PfInputVariant;
+            size?: "xs" | "sm" | "md" | "lg" | "xl";
+            required?: boolean;
+            autocomplete?: string;
+            autofocus?: boolean;
+            disabled?: boolean;
+            readonly?: boolean;
+            highlight?: boolean;
+            fixed?: boolean;
+            animatedText?: boolean;
+            ui?: import('../PfInput/index.vue').PfInputUi;
+            icon?: PfIconName;
+            avatar?: import('../../..').PfButtonAvatarProps;
+            leading?: boolean;
+            leadingIcon?: PfIconName;
+            trailing?: boolean;
+            trailingIcon?: PfIconName;
+            loading?: boolean;
+            loadingIcon?: PfIconName;
+            maxlength?: number;
+            minlength?: number;
+            pattern?: string;
+            list?: string;
+            form?: string;
+            enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send";
+        }> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        }>, "inputRef" | ("fixed" | "type" | "loading" | "color" | "variant" | "disabled" | "readonly" | "autocomplete" | "highlight" | "animatedText")> & import('vue').ShallowUnwrapRef<{
+            inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                leading?(_: {}): any;
+                default?(_: {}): any;
+                trailing?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    triggerRef: import('vue').ShallowRef<HTMLDivElement | null, HTMLDivElement | null>;
+    viewportRef: import('vue').ShallowRef<HTMLElement | null, HTMLElement | null>;
+    selectRef: import('vue').Ref<({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly id?: string | undefined;
+            readonly modelValue?: PfSelectModelValue;
+            readonly defaultValue?: PfSelectModelValue;
+            readonly options?: readonly PfSelectOption[] | undefined;
+            readonly optionGroups?: PfSelectOptionGroups | undefined;
+            readonly optionGroupLabels?: readonly (string | undefined)[] | undefined;
+            readonly placeholder?: string | undefined;
+            readonly multiple?: boolean | undefined;
+            readonly listboxRows?: number | undefined;
+            readonly native?: boolean | undefined;
+            readonly name?: string | undefined;
+            readonly required?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly autofocus?: boolean | undefined;
+            readonly form?: string | undefined;
+            readonly color?: PfSelectColor | undefined;
+            readonly variant?: PfSelectVariant | undefined;
+            readonly size?: PfSelectSize | undefined;
+            readonly highlight?: boolean | undefined;
+            readonly chevronIcon?: PfIconName | undefined;
+            readonly trailingIcon?: PfIconName | undefined;
+            readonly selectedOptionIcon?: (PfIconName | null) | undefined;
+            readonly leadingIcon?: PfIconName | undefined;
+            readonly leadingAvatar?: PfSelectOptionAvatarConfig | undefined;
+            readonly loading?: boolean | undefined;
+            readonly loadingIcon?: PfIconName | undefined;
+            readonly menuGap?: number | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly clearOptionLabel?: string | undefined;
+            readonly defaultOpen?: boolean | undefined;
+            readonly allowEmptyPanel?: boolean | undefined;
+            readonly optionFilter?: ((index: number, option: PfSelectOption) => boolean) | undefined;
+            readonly emptyText?: string | undefined;
+            readonly focusTriggerAfterSingleSelect?: boolean | undefined;
+            readonly ui?: PfSelectUi | undefined;
+            readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+            readonly onChange?: ((event: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+            readonly "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            shellRef: HTMLDivElement;
+            triggerRef: HTMLDivElement;
+            selectRef: HTMLSelectElement;
+            panelRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: PfSelectModelValue) => void) & ((event: "update:menuOpen", value: boolean) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            id?: string;
+            modelValue?: PfSelectModelValue;
+            defaultValue?: PfSelectModelValue;
+            options?: readonly PfSelectOption[];
+            optionGroups?: PfSelectOptionGroups;
+            optionGroupLabels?: readonly (string | undefined)[];
+            placeholder?: string;
+            multiple?: boolean;
+            listboxRows?: number;
+            native?: boolean;
+            name?: string;
+            required?: boolean;
+            disabled?: boolean;
+            autocomplete?: string;
+            autofocus?: boolean;
+            form?: string;
+            color?: PfSelectColor;
+            variant?: PfSelectVariant;
+            size?: PfSelectSize;
+            highlight?: boolean;
+            chevronIcon?: PfIconName;
+            trailingIcon?: PfIconName;
+            selectedOptionIcon?: PfIconName | null;
+            leadingIcon?: PfIconName;
+            leadingAvatar?: PfSelectOptionAvatarConfig;
+            loading?: boolean;
+            loadingIcon?: PfIconName;
+            menuGap?: number;
+            clearable?: boolean;
+            clearOptionLabel?: string;
+            defaultOpen?: boolean;
+            allowEmptyPanel?: boolean;
+            optionFilter?: (index: number, option: PfSelectOption) => boolean;
+            emptyText?: string;
+            focusTriggerAfterSingleSelect?: boolean;
+            ui?: PfSelectUi;
+        }> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+            "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+        }>, {
+            selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+            triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+            panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            open: () => void;
+            close: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: PfSelectModelValue) => any;
+            "update:menuOpen": (value: boolean) => any;
+        }, string, {
+            required: boolean;
+            loading: boolean;
+            color: PfSelectColor;
+            variant: PfSelectVariant;
+            disabled: boolean;
+            multiple: boolean;
+            autocomplete: string;
+            highlight: boolean;
+            native: boolean;
+            menuGap: number;
+            clearable: boolean;
+            allowEmptyPanel: boolean;
+            emptyText: string;
+            focusTriggerAfterSingleSelect: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        required: boolean;
+        loading: boolean;
+        color: PfSelectColor;
+        variant: PfSelectVariant;
+        disabled: boolean;
+        multiple: boolean;
+        autocomplete: string;
+        highlight: boolean;
+        native: boolean;
+        menuGap: number;
+        clearable: boolean;
+        allowEmptyPanel: boolean;
+        emptyText: string;
+        focusTriggerAfterSingleSelect: boolean;
+    }> & Omit<Readonly<{
+        id?: string;
+        modelValue?: PfSelectModelValue;
+        defaultValue?: PfSelectModelValue;
+        options?: readonly PfSelectOption[];
+        optionGroups?: PfSelectOptionGroups;
+        optionGroupLabels?: readonly (string | undefined)[];
+        placeholder?: string;
+        multiple?: boolean;
+        listboxRows?: number;
+        native?: boolean;
+        name?: string;
+        required?: boolean;
+        disabled?: boolean;
+        autocomplete?: string;
+        autofocus?: boolean;
+        form?: string;
+        color?: PfSelectColor;
+        variant?: PfSelectVariant;
+        size?: PfSelectSize;
+        highlight?: boolean;
+        chevronIcon?: PfIconName;
+        trailingIcon?: PfIconName;
+        selectedOptionIcon?: PfIconName | null;
+        leadingIcon?: PfIconName;
+        leadingAvatar?: PfSelectOptionAvatarConfig;
+        loading?: boolean;
+        loadingIcon?: PfIconName;
+        menuGap?: number;
+        clearable?: boolean;
+        clearOptionLabel?: string;
+        defaultOpen?: boolean;
+        allowEmptyPanel?: boolean;
+        optionFilter?: (index: number, option: PfSelectOption) => boolean;
+        emptyText?: string;
+        focusTriggerAfterSingleSelect?: boolean;
+        ui?: PfSelectUi;
+    }> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+        "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+    }>, "close" | "open" | "selectRef" | "triggerRef" | "panelRef" | ("required" | "loading" | "color" | "variant" | "disabled" | "multiple" | "autocomplete" | "highlight" | "native" | "menuGap" | "clearable" | "allowEmptyPanel" | "emptyText" | "focusTriggerAfterSingleSelect")> & import('vue').ShallowUnwrapRef<{
+        selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+        triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+        panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        open: () => void;
+        close: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            leading?(_: {}): any;
+            leading?(_: {}): any;
+            trigger?(_: {
+                comboboxAttrs: Record<string, string | boolean | undefined>;
+                togglePanel: () => void;
+                openPanel: () => void;
+                closePanel: () => void;
+            }): any;
+            panelTop?(_: {}): any;
+            panelEmpty?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) | null, ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly id?: string | undefined;
+            readonly modelValue?: PfSelectModelValue;
+            readonly defaultValue?: PfSelectModelValue;
+            readonly options?: readonly PfSelectOption[] | undefined;
+            readonly optionGroups?: PfSelectOptionGroups | undefined;
+            readonly optionGroupLabels?: readonly (string | undefined)[] | undefined;
+            readonly placeholder?: string | undefined;
+            readonly multiple?: boolean | undefined;
+            readonly listboxRows?: number | undefined;
+            readonly native?: boolean | undefined;
+            readonly name?: string | undefined;
+            readonly required?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly autofocus?: boolean | undefined;
+            readonly form?: string | undefined;
+            readonly color?: PfSelectColor | undefined;
+            readonly variant?: PfSelectVariant | undefined;
+            readonly size?: PfSelectSize | undefined;
+            readonly highlight?: boolean | undefined;
+            readonly chevronIcon?: PfIconName | undefined;
+            readonly trailingIcon?: PfIconName | undefined;
+            readonly selectedOptionIcon?: (PfIconName | null) | undefined;
+            readonly leadingIcon?: PfIconName | undefined;
+            readonly leadingAvatar?: PfSelectOptionAvatarConfig | undefined;
+            readonly loading?: boolean | undefined;
+            readonly loadingIcon?: PfIconName | undefined;
+            readonly menuGap?: number | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly clearOptionLabel?: string | undefined;
+            readonly defaultOpen?: boolean | undefined;
+            readonly allowEmptyPanel?: boolean | undefined;
+            readonly optionFilter?: ((index: number, option: PfSelectOption) => boolean) | undefined;
+            readonly emptyText?: string | undefined;
+            readonly focusTriggerAfterSingleSelect?: boolean | undefined;
+            readonly ui?: PfSelectUi | undefined;
+            readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+            readonly onChange?: ((event: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+            readonly "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            shellRef: HTMLDivElement;
+            triggerRef: HTMLDivElement;
+            selectRef: HTMLSelectElement;
+            panelRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: PfSelectModelValue) => void) & ((event: "update:menuOpen", value: boolean) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            id?: string;
+            modelValue?: PfSelectModelValue;
+            defaultValue?: PfSelectModelValue;
+            options?: readonly PfSelectOption[];
+            optionGroups?: PfSelectOptionGroups;
+            optionGroupLabels?: readonly (string | undefined)[];
+            placeholder?: string;
+            multiple?: boolean;
+            listboxRows?: number;
+            native?: boolean;
+            name?: string;
+            required?: boolean;
+            disabled?: boolean;
+            autocomplete?: string;
+            autofocus?: boolean;
+            form?: string;
+            color?: PfSelectColor;
+            variant?: PfSelectVariant;
+            size?: PfSelectSize;
+            highlight?: boolean;
+            chevronIcon?: PfIconName;
+            trailingIcon?: PfIconName;
+            selectedOptionIcon?: PfIconName | null;
+            leadingIcon?: PfIconName;
+            leadingAvatar?: PfSelectOptionAvatarConfig;
+            loading?: boolean;
+            loadingIcon?: PfIconName;
+            menuGap?: number;
+            clearable?: boolean;
+            clearOptionLabel?: string;
+            defaultOpen?: boolean;
+            allowEmptyPanel?: boolean;
+            optionFilter?: (index: number, option: PfSelectOption) => boolean;
+            emptyText?: string;
+            focusTriggerAfterSingleSelect?: boolean;
+            ui?: PfSelectUi;
+        }> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+            "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+        }>, {
+            selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+            triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+            panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            open: () => void;
+            close: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: PfSelectModelValue) => any;
+            "update:menuOpen": (value: boolean) => any;
+        }, string, {
+            required: boolean;
+            loading: boolean;
+            color: PfSelectColor;
+            variant: PfSelectVariant;
+            disabled: boolean;
+            multiple: boolean;
+            autocomplete: string;
+            highlight: boolean;
+            native: boolean;
+            menuGap: number;
+            clearable: boolean;
+            allowEmptyPanel: boolean;
+            emptyText: string;
+            focusTriggerAfterSingleSelect: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        required: boolean;
+        loading: boolean;
+        color: PfSelectColor;
+        variant: PfSelectVariant;
+        disabled: boolean;
+        multiple: boolean;
+        autocomplete: string;
+        highlight: boolean;
+        native: boolean;
+        menuGap: number;
+        clearable: boolean;
+        allowEmptyPanel: boolean;
+        emptyText: string;
+        focusTriggerAfterSingleSelect: boolean;
+    }> & Omit<Readonly<{
+        id?: string;
+        modelValue?: PfSelectModelValue;
+        defaultValue?: PfSelectModelValue;
+        options?: readonly PfSelectOption[];
+        optionGroups?: PfSelectOptionGroups;
+        optionGroupLabels?: readonly (string | undefined)[];
+        placeholder?: string;
+        multiple?: boolean;
+        listboxRows?: number;
+        native?: boolean;
+        name?: string;
+        required?: boolean;
+        disabled?: boolean;
+        autocomplete?: string;
+        autofocus?: boolean;
+        form?: string;
+        color?: PfSelectColor;
+        variant?: PfSelectVariant;
+        size?: PfSelectSize;
+        highlight?: boolean;
+        chevronIcon?: PfIconName;
+        trailingIcon?: PfIconName;
+        selectedOptionIcon?: PfIconName | null;
+        leadingIcon?: PfIconName;
+        leadingAvatar?: PfSelectOptionAvatarConfig;
+        loading?: boolean;
+        loadingIcon?: PfIconName;
+        menuGap?: number;
+        clearable?: boolean;
+        clearOptionLabel?: string;
+        defaultOpen?: boolean;
+        allowEmptyPanel?: boolean;
+        optionFilter?: (index: number, option: PfSelectOption) => boolean;
+        emptyText?: string;
+        focusTriggerAfterSingleSelect?: boolean;
+        ui?: PfSelectUi;
+    }> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+        "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+    }>, "close" | "open" | "selectRef" | "triggerRef" | "panelRef" | ("required" | "loading" | "color" | "variant" | "disabled" | "multiple" | "autocomplete" | "highlight" | "native" | "menuGap" | "clearable" | "allowEmptyPanel" | "emptyText" | "focusTriggerAfterSingleSelect")> & import('vue').ShallowUnwrapRef<{
+        selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+        triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+        panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        open: () => void;
+        close: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            leading?(_: {}): any;
+            leading?(_: {}): any;
+            trigger?(_: {
+                comboboxAttrs: Record<string, string | boolean | undefined>;
+                togglePanel: () => void;
+                openPanel: () => void;
+                closePanel: () => void;
+            }): any;
+            panelTop?(_: {}): any;
+            panelEmpty?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) | null>;
+    inputRef: import('vue').ShallowRef<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    blur: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    "update:modelValue": (value: unknown) => any;
+    "update:search-term": (value: string) => any;
+    "remove-tag": (item: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+    "onUpdate:search-term"?: ((value: string) => any) | undefined;
+    "onRemove-tag"?: ((item: unknown) => any) | undefined;
+}>, {
+    size: PfSelectSize;
+    required: boolean;
+    loading: boolean;
+    color: PfSelectColor;
+    variant: PfSelectVariant;
+    disabled: boolean;
+    multiple: boolean;
+    labelKey: string;
+    descriptionKey: string;
+    items: PfInputMenuItems;
+    highlight: boolean;
+    animatedText: boolean;
+    menuGap: number;
+    clearable: boolean;
+    ignoreFilter: boolean;
+    resetSearchTermOnBlur: boolean;
+    resetSearchTermOnSelect: boolean;
+    openOnFocus: boolean;
+    openOnClick: boolean;
+    deleteIcon: PfIconName;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    selectRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly id?: string | undefined;
+            readonly modelValue?: PfSelectModelValue;
+            readonly defaultValue?: PfSelectModelValue;
+            readonly options?: readonly PfSelectOption[] | undefined;
+            readonly optionGroups?: PfSelectOptionGroups | undefined;
+            readonly optionGroupLabels?: readonly (string | undefined)[] | undefined;
+            readonly placeholder?: string | undefined;
+            readonly multiple?: boolean | undefined;
+            readonly listboxRows?: number | undefined;
+            readonly native?: boolean | undefined;
+            readonly name?: string | undefined;
+            readonly required?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly autofocus?: boolean | undefined;
+            readonly form?: string | undefined;
+            readonly color?: PfSelectColor | undefined;
+            readonly variant?: PfSelectVariant | undefined;
+            readonly size?: PfSelectSize | undefined;
+            readonly highlight?: boolean | undefined;
+            readonly chevronIcon?: PfIconName | undefined;
+            readonly trailingIcon?: PfIconName | undefined;
+            readonly selectedOptionIcon?: (PfIconName | null) | undefined;
+            readonly leadingIcon?: PfIconName | undefined;
+            readonly leadingAvatar?: PfSelectOptionAvatarConfig | undefined;
+            readonly loading?: boolean | undefined;
+            readonly loadingIcon?: PfIconName | undefined;
+            readonly menuGap?: number | undefined;
+            readonly clearable?: boolean | undefined;
+            readonly clearOptionLabel?: string | undefined;
+            readonly defaultOpen?: boolean | undefined;
+            readonly allowEmptyPanel?: boolean | undefined;
+            readonly optionFilter?: ((index: number, option: PfSelectOption) => boolean) | undefined;
+            readonly emptyText?: string | undefined;
+            readonly focusTriggerAfterSingleSelect?: boolean | undefined;
+            readonly ui?: PfSelectUi | undefined;
+            readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+            readonly onChange?: ((event: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+            readonly "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            shellRef: HTMLDivElement;
+            triggerRef: HTMLDivElement;
+            selectRef: HTMLSelectElement;
+            panelRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: PfSelectModelValue) => void) & ((event: "update:menuOpen", value: boolean) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            id?: string;
+            modelValue?: PfSelectModelValue;
+            defaultValue?: PfSelectModelValue;
+            options?: readonly PfSelectOption[];
+            optionGroups?: PfSelectOptionGroups;
+            optionGroupLabels?: readonly (string | undefined)[];
+            placeholder?: string;
+            multiple?: boolean;
+            listboxRows?: number;
+            native?: boolean;
+            name?: string;
+            required?: boolean;
+            disabled?: boolean;
+            autocomplete?: string;
+            autofocus?: boolean;
+            form?: string;
+            color?: PfSelectColor;
+            variant?: PfSelectVariant;
+            size?: PfSelectSize;
+            highlight?: boolean;
+            chevronIcon?: PfIconName;
+            trailingIcon?: PfIconName;
+            selectedOptionIcon?: PfIconName | null;
+            leadingIcon?: PfIconName;
+            leadingAvatar?: PfSelectOptionAvatarConfig;
+            loading?: boolean;
+            loadingIcon?: PfIconName;
+            menuGap?: number;
+            clearable?: boolean;
+            clearOptionLabel?: string;
+            defaultOpen?: boolean;
+            allowEmptyPanel?: boolean;
+            optionFilter?: (index: number, option: PfSelectOption) => boolean;
+            emptyText?: string;
+            focusTriggerAfterSingleSelect?: boolean;
+            ui?: PfSelectUi;
+        }> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+            "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+        }>, {
+            selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+            triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+            panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            open: () => void;
+            close: () => void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: PfSelectModelValue) => any;
+            "update:menuOpen": (value: boolean) => any;
+        }, string, {
+            required: boolean;
+            loading: boolean;
+            color: PfSelectColor;
+            variant: PfSelectVariant;
+            disabled: boolean;
+            multiple: boolean;
+            autocomplete: string;
+            highlight: boolean;
+            native: boolean;
+            menuGap: number;
+            clearable: boolean;
+            allowEmptyPanel: boolean;
+            emptyText: string;
+            focusTriggerAfterSingleSelect: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        required: boolean;
+        loading: boolean;
+        color: PfSelectColor;
+        variant: PfSelectVariant;
+        disabled: boolean;
+        multiple: boolean;
+        autocomplete: string;
+        highlight: boolean;
+        native: boolean;
+        menuGap: number;
+        clearable: boolean;
+        allowEmptyPanel: boolean;
+        emptyText: string;
+        focusTriggerAfterSingleSelect: boolean;
+    }> & Omit<Readonly<{
+        id?: string;
+        modelValue?: PfSelectModelValue;
+        defaultValue?: PfSelectModelValue;
+        options?: readonly PfSelectOption[];
+        optionGroups?: PfSelectOptionGroups;
+        optionGroupLabels?: readonly (string | undefined)[];
+        placeholder?: string;
+        multiple?: boolean;
+        listboxRows?: number;
+        native?: boolean;
+        name?: string;
+        required?: boolean;
+        disabled?: boolean;
+        autocomplete?: string;
+        autofocus?: boolean;
+        form?: string;
+        color?: PfSelectColor;
+        variant?: PfSelectVariant;
+        size?: PfSelectSize;
+        highlight?: boolean;
+        chevronIcon?: PfIconName;
+        trailingIcon?: PfIconName;
+        selectedOptionIcon?: PfIconName | null;
+        leadingIcon?: PfIconName;
+        leadingAvatar?: PfSelectOptionAvatarConfig;
+        loading?: boolean;
+        loadingIcon?: PfIconName;
+        menuGap?: number;
+        clearable?: boolean;
+        clearOptionLabel?: string;
+        defaultOpen?: boolean;
+        allowEmptyPanel?: boolean;
+        optionFilter?: (index: number, option: PfSelectOption) => boolean;
+        emptyText?: string;
+        focusTriggerAfterSingleSelect?: boolean;
+        ui?: PfSelectUi;
+    }> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+        "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+    }>, "close" | "open" | "selectRef" | "triggerRef" | "panelRef" | ("required" | "loading" | "color" | "variant" | "disabled" | "multiple" | "autocomplete" | "highlight" | "native" | "menuGap" | "clearable" | "allowEmptyPanel" | "emptyText" | "focusTriggerAfterSingleSelect")> & import('vue').ShallowUnwrapRef<{
+        selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+        triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+        panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        open: () => void;
+        close: () => void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            leading?(_: {}): any;
+            leading?(_: {}): any;
+            trigger?(_: {
+                comboboxAttrs: Record<string, string | boolean | undefined>;
+                togglePanel: () => void;
+                openPanel: () => void;
+                closePanel: () => void;
+            }): any;
+            panelTop?(_: {}): any;
+            panelEmpty?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) | null;
+    inputComponentRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: string | undefined;
+            readonly id?: string | undefined;
+            readonly name?: string | undefined;
+            readonly type?: string | undefined;
+            readonly placeholder?: string | undefined;
+            readonly color?: import('../PfInput/index.vue').PfInputColor | undefined;
+            readonly variant?: import('../PfInput/index.vue').PfInputVariant | undefined;
+            readonly size?: "xs" | "sm" | "md" | "lg" | "xl" | undefined;
+            readonly required?: boolean | undefined;
+            readonly autocomplete?: string | undefined;
+            readonly autofocus?: boolean | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly highlight?: boolean | undefined;
+            readonly fixed?: boolean | undefined;
+            readonly animatedText?: boolean | undefined;
+            readonly ui?: import('../PfInput/index.vue').PfInputUi | undefined;
+            readonly icon?: PfIconName | undefined;
+            readonly avatar?: import('../../..').PfButtonAvatarProps | undefined;
+            readonly leading?: boolean | undefined;
+            readonly leadingIcon?: PfIconName | undefined;
+            readonly trailing?: boolean | undefined;
+            readonly trailingIcon?: PfIconName | undefined;
+            readonly loading?: boolean | undefined;
+            readonly loadingIcon?: PfIconName | undefined;
+            readonly maxlength?: number | undefined;
+            readonly minlength?: number | undefined;
+            readonly pattern?: string | undefined;
+            readonly list?: string | undefined;
+            readonly form?: string | undefined;
+            readonly enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send" | undefined;
+            readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+            readonly onChange?: ((event: Event) => any) | undefined;
+            readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            valueCellRef: HTMLDivElement;
+            inputRef: HTMLInputElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "blur", event: FocusEvent) => void) & ((event: "change", event: Event) => void) & ((event: "update:modelValue", value: string) => void);
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<{
+            modelValue?: string;
+        } & {
+            id?: string;
+            name?: string;
+            type?: string;
+            placeholder?: string;
+            color?: import('../PfInput/index.vue').PfInputColor;
+            variant?: import('../PfInput/index.vue').PfInputVariant;
+            size?: "xs" | "sm" | "md" | "lg" | "xl";
+            required?: boolean;
+            autocomplete?: string;
+            autofocus?: boolean;
+            disabled?: boolean;
+            readonly?: boolean;
+            highlight?: boolean;
+            fixed?: boolean;
+            animatedText?: boolean;
+            ui?: import('../PfInput/index.vue').PfInputUi;
+            icon?: PfIconName;
+            avatar?: import('../../..').PfButtonAvatarProps;
+            leading?: boolean;
+            leadingIcon?: PfIconName;
+            trailing?: boolean;
+            trailingIcon?: PfIconName;
+            loading?: boolean;
+            loadingIcon?: PfIconName;
+            maxlength?: number;
+            minlength?: number;
+            pattern?: string;
+            list?: string;
+            form?: string;
+            enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send";
+        }> & Readonly<{
+            onBlur?: ((event: FocusEvent) => any) | undefined;
+            onChange?: ((event: Event) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        }>, {
+            inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            blur: (event: FocusEvent) => any;
+            change: (event: Event) => any;
+            "update:modelValue": (value: string) => any;
+        }, string, {
+            fixed: boolean;
+            type: string;
+            loading: boolean;
+            color: import('../PfInput/index.vue').PfInputColor;
+            variant: import('../PfInput/index.vue').PfInputVariant;
+            disabled: boolean;
+            readonly: boolean;
+            autocomplete: string;
+            highlight: boolean;
+            animatedText: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        fixed: boolean;
+        type: string;
+        loading: boolean;
+        color: import('../PfInput/index.vue').PfInputColor;
+        variant: import('../PfInput/index.vue').PfInputVariant;
+        disabled: boolean;
+        readonly: boolean;
+        autocomplete: string;
+        highlight: boolean;
+        animatedText: boolean;
+    }> & Omit<Readonly<{
+        modelValue?: string;
+    } & {
+        id?: string;
+        name?: string;
+        type?: string;
+        placeholder?: string;
+        color?: import('../PfInput/index.vue').PfInputColor;
+        variant?: import('../PfInput/index.vue').PfInputVariant;
+        size?: "xs" | "sm" | "md" | "lg" | "xl";
+        required?: boolean;
+        autocomplete?: string;
+        autofocus?: boolean;
+        disabled?: boolean;
+        readonly?: boolean;
+        highlight?: boolean;
+        fixed?: boolean;
+        animatedText?: boolean;
+        ui?: import('../PfInput/index.vue').PfInputUi;
+        icon?: PfIconName;
+        avatar?: import('../../..').PfButtonAvatarProps;
+        leading?: boolean;
+        leadingIcon?: PfIconName;
+        trailing?: boolean;
+        trailingIcon?: PfIconName;
+        loading?: boolean;
+        loadingIcon?: PfIconName;
+        maxlength?: number;
+        minlength?: number;
+        pattern?: string;
+        list?: string;
+        form?: string;
+        enterKeyHint?: "search" | "enter" | "done" | "go" | "next" | "previous" | "send";
+    }> & Readonly<{
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onChange?: ((event: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }>, "inputRef" | ("fixed" | "type" | "loading" | "color" | "variant" | "disabled" | "readonly" | "autocomplete" | "highlight" | "animatedText")> & import('vue').ShallowUnwrapRef<{
+        inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            leading?(_: {}): any;
+            default?(_: {}): any;
+            trailing?(_: {}): any;
+        };
+    }) | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};