@adyen/bento-vue2 0.9.0 → 0.9.2

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

@@ -2,6 +2,253 @@ 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").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;
+        }>;
+        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").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").ComponentOptionsMixin, import("vue/types/v3-component-options").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;
@@ -9,12 +256,12 @@ declare const _default: import("vue").DefineComponent<{
     };
     targetElement: {
         type: PropType<VueNodeElement>;
-        required: true;
+        required: boolean;
     };
     position: {
         type: PropType<import("@/components/popper-container").PopperContainerPositionBasic>;
         default: import("@/components/popper-container").PopperContainerPositionBasic;
-        validator: (value: unknown) => boolean;
+        validator: (value: any) => boolean;
     };
     offset: {
         type: NumberConstructor;
@@ -22,7 +269,7 @@ declare const _default: import("vue").DefineComponent<{
     };
     content: {
         type: StringConstructor;
-        required: true;
+        required: boolean;
     };
     isShown: {
         type: BooleanConstructor;
@@ -44,12 +291,12 @@ declare const _default: import("vue").DefineComponent<{
     };
     targetElement: {
         type: PropType<VueNodeElement>;
-        required: true;
+        required: boolean;
     };
     position: {
         type: PropType<import("@/components/popper-container").PopperContainerPositionBasic>;
         default: import("@/components/popper-container").PopperContainerPositionBasic;
-        validator: (value: unknown) => boolean;
+        validator: (value: any) => boolean;
     };
     offset: {
         type: NumberConstructor;
@@ -57,15 +304,15 @@ declare const _default: import("vue").DefineComponent<{
     };
     content: {
         type: StringConstructor;
-        required: true;
+        required: boolean;
     };
     isShown: {
         type: BooleanConstructor;
         default: boolean;
     };
 }>>, {
-    offset: number;
     id: string;
+    offset: number;
     position: import("@/components/popper-container").PopperContainerPositionBasic;
     isShown: boolean;
 }>;

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

@@ -67,12 +67,12 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
 }>>, {
-    medium: boolean;
     el: BentoTypographyElement;
-    large: boolean;
     wide: boolean;
     stronger: boolean;
     strongest: boolean;
     variant: BentoTypographyVariant;
+    medium: boolean;
+    large: boolean;
 }>;
 export default _default;

package/dist/@types/directives/tooltip/tooltip.d.ts

@@ -1,2 +1,9 @@
-import { DirectiveOptions } from 'vue';
-export declare const BentoTooltipDirective: DirectiveOptions;
+export declare const BentoTooltipDirective: {
+    bind(el: any, binding: any): void;
+    update(el: any, binding: any): void;
+    unbind(el: any): void;
+    beforeMount(el: any, binding: any): void;
+    mounted(el: any, binding: any): void;
+    updated(el: any, binding: any): void;
+    unmounted(el: any): void;
+};

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

@@ -1,8 +1,7 @@
-import Vue from 'vue';
-import type { ComponentPublicInstance } from 'vue';
+import type { Component, ComponentPublicInstance } from 'vue';
 import { MaybeComputedRef, MaybeRef } from './refs';
 export type VueInstance = ComponentPublicInstance;
-export type VueNodeElement = Vue | Element | (Vue | Element)[] | undefined;
+export type VueNodeElement = Component | Element | (Component | Element)[] | undefined;
 export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
 export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
 export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeComputedRef<T>;

package/dist/@types/{components/focus-trap → utils/ts}/focus-trap.utils.d.ts

@@ -1,4 +1,4 @@
-import { BentoFocusTrapHorizontalNavigationEvent, BentoFocusTrapVerticalNavigationEvent } from './focus-trap.types';
+import { BentoFocusTrapHorizontalNavigationEvent, BentoFocusTrapVerticalNavigationEvent } from '@/components/focus-trap/focus-trap.types';
 export declare const deferAction: (callback: FrameRequestCallback) => number;
 export declare const getNextFocusableElement: (factor: any, element: any) => HTMLElement;
 export declare const getArrowType: (event: KeyboardEvent, arrowOrder: BentoFocusTrapVerticalNavigationEvent[] | BentoFocusTrapHorizontalNavigationEvent[]) => {

package/dist/@types/utils/ts/i18n.d.ts

@@ -18,4 +18,15 @@ export interface Composer {
     d: typeof VueI18n.prototype.d;
     n: typeof VueI18n.prototype.n;
 }
-export declare function useI18n(): Composer;
+interface i18nMessages {
+    'en-US': {
+        [key: string]: string;
+    };
+    [key: string]: {
+        [key: string]: string;
+    };
+}
+export declare function useI18n(params?: {
+    messages?: i18nMessages;
+} | undefined, onlyLocale?: boolean): Composer | any;
+export {};

package/dist/@types/utils/ts/toastController.d.ts

@@ -1,3 +1,2 @@
 import BentoToastController from '../../plugins/toastController';
 export declare function useBentoToastController(): BentoToastController;
-export declare function installToastControllerPlugin(): void;