@adyen/bento-vue3 0.9.3

package/dist/@types/components/toggle/toggle.vue.d.ts

@@ -0,0 +1,60 @@
+import { PropType } from 'vue';
+import { BentoTypographyElement, BentoTypographyVariant } from '@/components/typography';
+import { AdlLabelPosition } from '@/types';
+declare const _default: import("vue").DefineComponent<{
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelPosition: {
+        type: PropType<AdlLabelPosition>;
+        default: AdlLabelPosition;
+        validator: (value: AdlLabelPosition) => boolean;
+    };
+    value: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+}, {
+    toggleInput: import("vue").Ref<any>;
+    BentoTypographyElement: typeof BentoTypographyElement;
+    BentoTypographyVariant: typeof BentoTypographyVariant;
+    computedAriaLabel: import("vue").ComputedRef<string>;
+    computedDescription: import("vue").ComputedRef<string>;
+    defaultSlotValue: boolean;
+    descriptionSlotValue: boolean;
+    conditionalClasses: import("vue").ComputedRef<{
+        [key: string]: boolean;
+    }>;
+    descriptionId: string;
+    isChecked: () => boolean;
+    onChange: (event: Event) => void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "input"[], string, Readonly<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelPosition: {
+        type: PropType<AdlLabelPosition>;
+        default: AdlLabelPosition;
+        validator: (value: AdlLabelPosition) => boolean;
+    };
+    value: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+}>>, {
+    value: boolean;
+    disabled: boolean;
+    ariaLabel: string;
+    labelPosition: AdlLabelPosition;
+}>;
+export default _default;

package/dist/@types/components/tooltip/tooltip.vue.d.ts

@@ -0,0 +1,319 @@
+import { PropType } from 'vue';
+import { PopperContainerAriaRole, PopperContainerPositionExtended } from '@/components/popper-container';
+import { BentoTypographyElement, BentoTypographyVariant } from '@/components/typography';
+import { VueNodeElement } from '@/types';
+export declare const Tooltip: {
+    name: string;
+    components: {
+        BentoTypography: import("vue").DefineComponent<{
+            el: {
+                type: PropType<BentoTypographyElement>;
+                default: BentoTypographyElement;
+                validator: (value: BentoTypographyElement) => boolean;
+            };
+            stronger: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            strongest: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            variant: {
+                type: PropType<BentoTypographyVariant>;
+                default: BentoTypographyVariant;
+                validator: (value: BentoTypographyVariant) => boolean;
+            };
+            medium: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            large: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wide: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }, {
+            conditionalClasses: import("vue").ComputedRef<{
+                [x: string]: boolean;
+            }>;
+        }, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+            el: {
+                type: PropType<BentoTypographyElement>;
+                default: BentoTypographyElement;
+                validator: (value: BentoTypographyElement) => boolean;
+            };
+            stronger: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            strongest: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            variant: {
+                type: PropType<BentoTypographyVariant>;
+                default: BentoTypographyVariant;
+                validator: (value: BentoTypographyVariant) => boolean;
+            };
+            medium: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            large: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wide: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>>, {
+            el: BentoTypographyElement;
+            wide: boolean;
+            stronger: boolean;
+            strongest: boolean;
+            variant: BentoTypographyVariant;
+            medium: boolean;
+            large: boolean;
+        }>;
+        PopperContainer: import("vue").DefineComponent<{
+            id: {
+                type: StringConstructor;
+                default: any;
+            };
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            targetElement: {
+                type: PropType<VueNodeElement>;
+                required: true;
+            };
+            position: {
+                type: PropType<import("@/components/popper-container").PopperContainerPosition>;
+                default: PopperContainerPositionExtended;
+                validator: (value: unknown) => boolean;
+            };
+            fixedPositioning: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            arrow: {
+                type: PropType<boolean | import("@/components/popper-container").PopperContainerArrowProp>;
+                default: any;
+            };
+            offset: {
+                type: PropType<number[]>;
+                default: () => number[];
+                validator: (value: number[]) => boolean;
+            };
+            matchWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabledFocusTrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            modifiers: {
+                type: ArrayConstructor;
+                default: any;
+            };
+            fallbackPosition: {
+                type: PropType<import("@/components/popper-container").FallbackPositionProp>;
+                default: any;
+            };
+            ariaRole: {
+                type: PropType<PopperContainerAriaRole>;
+                default: any;
+                validator: (value: unknown) => boolean;
+            };
+        }, {}, {
+            popper: any;
+            emittedPosition: any;
+        }, {
+            strategy(): import("@popperjs/core/index.js").PositioningStrategy;
+            allModifiers(): import("@/components/popper-container").ExtendedModifiers[];
+            arrowClasses(): string[];
+        }, {
+            initPopper(): void;
+            destroyPopper(): void;
+            updatePopperOptions(options: any): void;
+            updateModifiers(): void;
+        }, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+            id: {
+                type: StringConstructor;
+                default: any;
+            };
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            targetElement: {
+                type: PropType<VueNodeElement>;
+                required: true;
+            };
+            position: {
+                type: PropType<import("@/components/popper-container").PopperContainerPosition>;
+                default: PopperContainerPositionExtended;
+                validator: (value: unknown) => boolean;
+            };
+            fixedPositioning: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            arrow: {
+                type: PropType<boolean | import("@/components/popper-container").PopperContainerArrowProp>;
+                default: any;
+            };
+            offset: {
+                type: PropType<number[]>;
+                default: () => number[];
+                validator: (value: number[]) => boolean;
+            };
+            matchWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabledFocusTrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            modifiers: {
+                type: ArrayConstructor;
+                default: any;
+            };
+            fallbackPosition: {
+                type: PropType<import("@/components/popper-container").FallbackPositionProp>;
+                default: any;
+            };
+            ariaRole: {
+                type: PropType<PopperContainerAriaRole>;
+                default: any;
+                validator: (value: unknown) => boolean;
+            };
+        }>>, {
+            id: string;
+            ariaLabel: string;
+            modifiers: unknown[];
+            arrow: any;
+            offset: number[];
+            position: import("@/components/popper-container").PopperContainerPosition;
+            matchWidth: boolean;
+            fixedPositioning: boolean;
+            disabledFocusTrap: boolean;
+            fallbackPosition: import("@/components/popper-container").FallbackPositionProp;
+            ariaRole: PopperContainerAriaRole;
+        }>;
+    };
+    inheritAttrs: boolean;
+    props: {
+        id: {
+            type: StringConstructor;
+            default: any;
+        };
+        targetElement: {
+            type: PropType<VueNodeElement>;
+            required: boolean;
+        };
+        position: {
+            type: PropType<import("@/components/popper-container").PopperContainerPositionBasic>;
+            default: import("@/components/popper-container").PopperContainerPositionBasic;
+            validator: (value: any) => boolean;
+        };
+        offset: {
+            type: NumberConstructor;
+            default: number;
+        };
+        content: {
+            type: StringConstructor;
+            required: boolean;
+        };
+        isShown: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    };
+    setup(props: any): {
+        BentoTypographyElement: typeof BentoTypographyElement;
+        BentoTypographyVariant: typeof BentoTypographyVariant;
+        PopperContainerAriaRole: typeof PopperContainerAriaRole;
+        PopperContainerPositionExtended: typeof PopperContainerPositionExtended;
+        conditionalClasses: import("vue").ComputedRef<{
+            [x: string]: boolean;
+        }>;
+        tabIndex: import("vue").ComputedRef<number>;
+    };
+};
+declare const _default: import("vue").DefineComponent<{
+    id: {
+        type: StringConstructor;
+        default: any;
+    };
+    targetElement: {
+        type: PropType<VueNodeElement>;
+        required: boolean;
+    };
+    position: {
+        type: PropType<import("@/components/popper-container").PopperContainerPositionBasic>;
+        default: import("@/components/popper-container").PopperContainerPositionBasic;
+        validator: (value: any) => boolean;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    content: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isShown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    BentoTypographyElement: typeof BentoTypographyElement;
+    BentoTypographyVariant: typeof BentoTypographyVariant;
+    PopperContainerAriaRole: typeof PopperContainerAriaRole;
+    PopperContainerPositionExtended: typeof PopperContainerPositionExtended;
+    conditionalClasses: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+    tabIndex: import("vue").ComputedRef<number>;
+}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+        default: any;
+    };
+    targetElement: {
+        type: PropType<VueNodeElement>;
+        required: boolean;
+    };
+    position: {
+        type: PropType<import("@/components/popper-container").PopperContainerPositionBasic>;
+        default: import("@/components/popper-container").PopperContainerPositionBasic;
+        validator: (value: any) => boolean;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    content: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isShown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    id: string;
+    offset: number;
+    position: import("@/components/popper-container").PopperContainerPositionBasic;
+    isShown: boolean;
+}>;
+export default _default;

package/dist/@types/components/typography/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BentoTypography } from './typography.vue';
+export * from './typography.types';

package/dist/@types/components/typography/typography.types.d.ts

@@ -0,0 +1,27 @@
+export declare enum BentoTypographyVariant {
+    CAPTION = "caption",
+    BODY = "body",
+    SUBTITLE = "subtitle",
+    TITLE = "title"
+}
+export declare enum BentoTypographyModifier {
+    WIDE = "wide",
+    STRONGER = "stronger",
+    STRONGER_WIDE = "stronger-wide",
+    STRONGEST = "strongest",
+    STRONGEST_WIDE = "strongest-wide",
+    MEDIUM = "m",
+    LARGE = "l",
+    MOBILE = "mobile"
+}
+export declare enum BentoTypographyElement {
+    H1 = "h1",
+    H2 = "h2",
+    H3 = "h3",
+    H4 = "h4",
+    H5 = "h5",
+    H6 = "h6",
+    DIV = "div",
+    PARAGRAPH = "p",
+    SPAN = "span"
+}

package/dist/@types/components/typography/typography.vue.d.ts

@@ -0,0 +1,78 @@
+import { PropType } from 'vue';
+import { BentoTypographyElement, BentoTypographyVariant } from './typography.types';
+declare const _default: import("vue").DefineComponent<{
+    el: {
+        type: PropType<BentoTypographyElement>;
+        default: BentoTypographyElement;
+        validator: (value: BentoTypographyElement) => boolean;
+    };
+    stronger: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strongest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    variant: {
+        type: PropType<BentoTypographyVariant>;
+        default: BentoTypographyVariant;
+        validator: (value: BentoTypographyVariant) => boolean;
+    };
+    medium: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    large: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    conditionalClasses: import("vue").ComputedRef<{
+        [x: string]: boolean;
+    }>;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    el: {
+        type: PropType<BentoTypographyElement>;
+        default: BentoTypographyElement;
+        validator: (value: BentoTypographyElement) => boolean;
+    };
+    stronger: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strongest: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    variant: {
+        type: PropType<BentoTypographyVariant>;
+        default: BentoTypographyVariant;
+        validator: (value: BentoTypographyVariant) => boolean;
+    };
+    medium: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    large: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    el: BentoTypographyElement;
+    wide: boolean;
+    stronger: boolean;
+    strongest: boolean;
+    variant: BentoTypographyVariant;
+    medium: boolean;
+    large: boolean;
+}>;
+export default _default;

package/dist/@types/components.d.ts

@@ -0,0 +1,119 @@
+import {
+    // ADL
+    // AdlAccordion,
+    // AdlAccordionItem,
+    // AdlBadge,
+    // AdlSegmentedControl,
+    // AdlSegmentedOption,
+    // AdlTab,
+    // AdlTabs,
+    // AdlTextarea,
+
+    // Bento
+    BentoAlert,
+    BentoButton,
+    BentoButtonActions,
+    BentoButtonGroup,
+    BentoCard,
+    BentoCheckbox,
+    BentoCheckboxGroup,
+    BentoClickOutside,
+    BentoCountry,
+    BentoCurrency,
+    BentoDataGrid,
+    BentoDate,
+    BentoDatePicker,
+    BentoDivider,
+    BentoDropdown,
+    BentoDropdownAvatar,
+    BentoDropdownCountry,
+    BentoDropdownCurrency,
+    BentoDropdownPaymentMethod,
+    BentoHeader,
+    BentoInfoIcon,
+    BentoInputField,
+    BentoLink,
+    BentoLoadingButton,
+    BentoLoadingIndicator,
+    BentoMenu,
+    BentoModal,
+    BentoPagination,
+    BentoPaymentMethod,
+    BentoPopover,
+    BentoRadioGroup,
+    BentoSearchBar,
+    BentoStatus,
+    BentoStructuredList,
+    BentoSummaryGrid,
+    BentoSummaryGridItemAmount,
+    BentoSummaryGridItemCustom,
+    BentoSummaryGridItemNumeric,
+    BentoSummaryGridItemPercentage,
+    BentoSummaryGridItemText,
+    BentoTabs,
+    BentoTag,
+    BentoToast,
+    BentoToggle,
+    BentoTypography,
+} from './index';
+
+declare module 'vue' {
+    export interface GlobalComponents {
+        // ADL
+        // AdlAccordion: typeof AdlAccordion;
+        // AdlAccordionItem: typeof AdlAccordionItem;
+        // AdlBadge: typeof AdlBadge;
+        // AdlSegmentedControl: typeof AdlSegmentedControl;
+        // AdlSegmentedOption: typeof AdlSegmentedOption;
+        // AdlTabs: typeof AdlTabs;
+        // AdlTab: typeof AdlTab;
+        // AdlTextarea: typeof AdlTextarea;
+
+        // Bento
+        BentoAlert: typeof BentoAlert;
+        BentoButton: typeof BentoButton;
+        BentoButtonGroup: typeof BentoButtonGroup;
+        BentoButtonActions: typeof BentoButtonActions;
+        BentoCard: typeof BentoCard;
+        BentoCheckbox: typeof BentoCheckbox;
+        BentoCheckboxGroup: typeof BentoCheckboxGroup;
+        BentoClickOutside: typeof BentoClickOutside;
+        BentoCountry: typeof BentoCountry;
+        BentoCurrency: typeof BentoCurrency;
+        BentoDataGrid: typeof BentoDataGrid;
+        BentoDate: typeof BentoDate;
+        BentoDatePicker: typeof BentoDatePicker;
+        BentoDivider: typeof BentoDivider;
+        BentoDropdown: typeof BentoDropdown;
+        BentoDropdownAvatar: typeof BentoDropdownAvatar;
+        BentoDropdownCountry: typeof BentoDropdownCountry;
+        BentoHeader: typeof BentoHeader;
+        BentoInfoIcon: typeof BentoInfoIcon;
+        BentoDropdownCurrency: typeof BentoDropdownCurrency;
+        BentoDropdownPaymentMethod: typeof BentoDropdownPaymentMethod;
+        BentoInputField: typeof BentoInputField;
+        BentoLink: typeof BentoLink;
+        BentoLoadingButton: typeof BentoLoadingButton;
+        BentoLoadingIndicator: typeof BentoLoadingIndicator;
+        BentoMenu: typeof BentoMenu;
+        BentoModal: typeof BentoModal;
+        BentoPagination: typeof BentoPagination;
+        BentoPaymentMethod: typeof BentoPaymentMethod;
+        BentoPopover: typeof BentoPopover;
+        BentoRadioGroup: typeof BentoRadioGroup;
+        BentoSearchBar: typeof BentoSearchBar;
+        BentoStatus: typeof BentoStatus;
+        BentoStructuredList: typeof BentoStructuredList;
+        BentoSummaryGrid: typeof BentoSummaryGrid;
+        BentoSummaryGridItemAmount: typeof BentoSummaryGridItemAmount;
+        BentoSummaryGridItemCustom: typeof BentoSummaryGridItemCustom;
+        BentoSummaryGridItemPercentage: typeof BentoSummaryGridItemPercentage;
+        BentoSummaryGridItemNumeric: typeof BentoSummaryGridItemNumeric;
+        BentoSummaryGridItemText: typeof BentoSummaryGridItemText;
+        BentoTabs: typeof BentoTabs;
+        BentoTag: typeof BentoTag;
+        BentoToast: typeof BentoToast;
+        BentoToggle: typeof BentoToggle;
+        BentoTypography: typeof BentoTypography;
+    }
+}

package/dist/@types/composables/index.d.ts

@@ -0,0 +1,3 @@
+export * from './initials';
+export * from './use-default-slot-validator/use-default-slot-validator';
+export * from './use-checkbox-select-all/use-checkbox-select-all';

package/dist/@types/composables/initials.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef } from 'vue';
+import { MaybeRef } from '@/types';
+export declare const useInitials: (username: MaybeRef<string | null>) => ComputedRef<string | null>;

package/dist/@types/composables/use-checkbox-select-all/use-checkbox-select-all.d.ts

@@ -0,0 +1,8 @@
+import type { ComputedRef } from 'vue';
+import type { BentoListboxMultiSelectValue, Fn } from '@/types';
+import { BentoListboxOptions } from '@/types';
+export declare const useCheckboxSelectAll: (selectedItemsList: ComputedRef<BentoListboxMultiSelectValue>, items: ComputedRef<BentoListboxOptions>, selectAll: Fn, unselectAll: Fn) => {
+    isAllSelected: ComputedRef<boolean>;
+    isIndeterminate: ComputedRef<boolean>;
+    toggleSelectAll: (selectedValue: boolean) => void;
+};

package/dist/@types/composables/use-default-slot-validator/use-default-slot-validator.d.ts

@@ -0,0 +1 @@
+export declare const useDefaultSlotValidator: (componentName: string, hasDefaultSlot: boolean, ...hasOptionalSlots: boolean[]) => void;

package/dist/@types/composables/useDynamicImport.d.ts

@@ -0,0 +1,2 @@
+import { MaybeRef } from '@/types';
+export declare const useDynamicIconImport: (packageName: string, suffixSvgSrc: MaybeRef<string>, fallBackSrc: string) => import("vue").Ref<string>;

package/dist/@types/directives/click-outside/directive.d.ts

@@ -0,0 +1,6 @@
+import type { ObjectDirective } from 'vue';
+type Element = HTMLElement & {
+    __onClickOutside_stop?: () => void;
+};
+export declare const BentoClickOutsideDirective: ObjectDirective<Element>;
+export {};

package/dist/@types/directives/click-outside/index.d.ts

@@ -0,0 +1 @@
+export * from './directive';

package/dist/@types/directives/click-outside/on-click-outside.d.ts

@@ -0,0 +1,3 @@
+import type { MaybeElementRef } from '@/types';
+import type { OnClickOutsideHandler, OnClickOutsideOptions } from './types';
+export declare function onClickOutside<T extends OnClickOutsideOptions>(target: MaybeElementRef, handler: OnClickOutsideHandler, options?: T): () => void;

package/dist/@types/directives/click-outside/types.d.ts

@@ -0,0 +1,8 @@
+import type { MaybeElementRef } from '@/types';
+export interface OnClickOutsideOptions {
+    ignore?: (MaybeElementRef | string)[];
+    capture?: boolean;
+    detectIframe?: boolean;
+    window?: Window;
+}
+export type OnClickOutsideHandler = (evt: PointerEvent | FocusEvent) => void;

package/dist/@types/directives/click-outside/useEventListener/index.d.ts

@@ -0,0 +1,7 @@
+import type { Fn, MaybeComputedRef } from '@/types';
+import type { Arrayable, GeneralEventListener } from './types';
+export declare function useEventListener<E extends keyof WindowEventMap>(event: Arrayable<E>, listener: Arrayable<(this: Window, ev: WindowEventMap[E]) => unknown>, options?: MaybeComputedRef<boolean | AddEventListenerOptions>): Fn;
+export declare function useEventListener<E extends keyof WindowEventMap>(target: Window, event: Arrayable<E>, listener: Arrayable<(this: Window, ev: WindowEventMap[E]) => unknown>, options?: MaybeComputedRef<boolean | AddEventListenerOptions>): Fn;
+export declare function useEventListener<E extends keyof DocumentEventMap>(target: DocumentOrShadowRoot, event: Arrayable<E>, listener: Arrayable<(this: Document, ev: DocumentEventMap[E]) => unknown>, options?: MaybeComputedRef<boolean | AddEventListenerOptions>): Fn;
+export declare function useEventListener<Names extends string, EventType = Event>(target: EventTarget, event: Arrayable<Names>, listener: Arrayable<GeneralEventListener<EventType>>, options?: MaybeComputedRef<boolean | AddEventListenerOptions>): Fn;
+export declare function useEventListener<EventType = Event>(target: MaybeComputedRef<EventTarget | null | undefined>, event: Arrayable<string>, listener: Arrayable<GeneralEventListener<EventType>>, options?: MaybeComputedRef<boolean | AddEventListenerOptions>): Fn;

package/dist/@types/directives/click-outside/useEventListener/types.d.ts

@@ -0,0 +1,6 @@
+export type Arrayable<T> = T[] | T;
+export type WindowEventName = keyof WindowEventMap;
+export type DocumentEventName = keyof DocumentEventMap;
+export interface GeneralEventListener<E = Event> {
+    (evt: E): void;
+}