@adyen/bento-vue3 1.21.1 → 1.22.0

package/dist/@types/packages/vue2/src/composables/use-form-validate/use-form.d.ts

@@ -2,7 +2,57 @@ import { Ref } from "../../../../vue3/node_modules/vue";
 import * as z from 'zod';
 import type { ZodSchema } from 'zod';
 import { ErrorBag, UseForm } from './use-form.types';
+/**
+ * Composable that tansforms a Zod schema into a Typed Schema that can be used alongside with {@see useForm}.
+ *
+ * This is meant to simulate the behavior of {@link @vee-validate/zod} {@see https://vee-validate.logaretm.com/v4/integrations/zod-schema-validation}.
+ * Function that transform Zod’s schemas into something that can be understood by vee-validate
+ *
+ * @param {T extends ZodSchema} formSchema Zod schema to be transformed into a `vee-validate` schema
+ * @returns {UseForm<T>} schema Schema transformed
+ */
 export declare function toTypedSchema<T extends ZodSchema>(formSchema: T): T;
+/**
+ * Composable that facilitates validating form data for Vue2 & Vue3 implementations with FormLayout
+ * to ease the migration to Vue3.
+ *
+ * For Vue3 implementations use Vee-Validate.
+ *
+ * This provides a simplified version of Vee-Validate v4 implemented with Zod to validate a form schema.
+ * It returns reactive values that can be used directly in form input elements with 'v-model' alongside
+ * with functions to "reset" the data (sets values to default value) and a function to execute the
+ * successful form validation process (through a callback).
+ *
+ * @param {UseForm<T>} props Form configuration object
+ * @param {T extends ZodSchema} props.validationSchema Zod typed validation schema
+ * @returns {Object} response - Composable with reactive form values and errors, and functions to handle the reactive data
+ * @returns {Ref<ErrorBag<T>>} response.errorBag Object with all the form values and an array of each one of the errors (if any) per value
+ * @returns {Ref<T>} response.errors Object with all the form values and the first error found for that field (if any)
+ * @returns {Ref<T>} response.values Object with all the form values and their current value
+ * @returns {() => void} response.handleReset Resets the form values to default (initial values) when it gets called
+ * @returns {(callback: (values: T) => void) => () => void} response.submitForm Validates the data set in {response.values} and sets errors (if found) inside {response.errors} and {response.errorBag}.
+ *                                                                   When the validation is successful it calls the callback so the submit process can continue
+ *
+ * @example
+ * const validationSchema = toTypedSchema(
+ *      z.object({
+ *          name: z
+ *              .string()
+ *              .min(3, { message: 'Name is required' })
+ *              .startsWith('Jane')
+ *              .max(4, { message: 'Name cannot be longer than 4 characters' })
+ *              .default('Joe'),
+ *      })
+ * );
+ *
+ * const { values, errors, errorBag, submitForm, handleReset } = useForm({
+ *     validationSchema
+ * });
+ * const handleSubmit = submitForm(() => {
+ *     // Send data to API here
+ * })
+ *
+ */
 export declare function useForm<T extends ZodSchema>({ validationSchema }: UseForm<T>): {
     errorBag: Ref<ErrorBag<z.TypeOf<T>>>;
     errors: z.TypeOf<T> extends infer T_1 ? T_1 extends z.TypeOf<T> ? T_1 extends Ref<any> ? T_1 : import("../../../../vue3/node_modules/vue").ShallowRef<T_1> : never : never;

package/dist/@types/packages/vue2/src/composables/use-form-validate/use-form.types.d.ts

@@ -1,5 +1,11 @@
 import type { typeToFlattenedError } from 'zod';
+/**
+ * Object of all the form field props with their respective list of errors
+ */
 export type ErrorBag<T> = typeToFlattenedError<T>['fieldErrors'];
+/**
+ * useForm composable configuration object
+ */
 export interface UseForm<T> {
     validationSchema: T;
 }

package/dist/@types/packages/vue2/src/composables/use-has-slot/use-has-slot.d.ts

@@ -1,5 +1,20 @@
 import { VNode } from "../../../../../node_modules/vue-demi";
 import type { Slots } from "../../../../vue3/node_modules/vue";
+/**
+ * Composable function that allows to verify if a Slot exits in a component.
+ *
+ * @example
+ * <script script lang="ts">
+ *    import { useHasSlot } from '@/composables/hasSlot';
+ *    import { useSlots } from 'vue';
+ *
+ *    const slots = useSlots();
+ *    const hasSlot = useHasSlot(slots);
+ * </script>
+ *
+ * @param {function(slots: Slots)} useHasSlots Encloses the slots object to be checked when the closure is called
+ * @returns {function(name: string)} Checks if the named slot defined by "name" exists in the component
+ */
 export declare const useHasSlot: (slots: Readonly<{
     [name: string]: import("../../../../../node_modules/vue-demi").Slot;
 }> | {

package/dist/@types/packages/vue2/src/composables/use-virtual-list/use-virtual-list.d.ts

@@ -1,5 +1,43 @@
 import { Ref } from "../../../../vue3/node_modules/vue";
 import type { UseVirtualListContainerProps, UseVirtualListOptions, UseVirtualListWrapperProps } from './use-virtual-list.types';
+/**
+ * Sets up a virtual scrolling functionality on a container element and a list of items to virtually scroll over.
+ * This composables returns the containerProps and wrapperProps objects that should be v-binded onto the container and wrapper elements
+ * of the list you wish to virtually scroll.
+ *
+ * This will return a filtered down list object the user can render based on how much the user has scrolled on the container.
+ *
+ * @usage
+ * <template>
+ *  <div v-bind="containerProps" @scroll="onScroll">
+ *    <ul v-bind="wrapperProps">
+ *      <li v-for="item in list" :key="item.index" style="height: 22px">
+ *        {{ item.label }}
+ *      </li>
+ *    </ul>
+ *  </div>
+ * </template>
+ *
+ * <script setup lang="ts"
+ * import { useVirtualList } from '@adyen/bento-vue2';
+ *
+ * const DEFAULT_OPTIONS: { label: string }[] = new Array(100)
+ *       .fill(0)
+ *       .map((_, index) => ({ label: `Option ${index + 1}` }));
+ * const ITEMS = ref(DEFAULT_OPTIONS);
+ * const ITEM_HEIGHT = 30;
+ *
+ * const { containerProps, wrapperProps, list, onScroll } = useVirtualList(ITEMS, { itemHeight: ITEM_HEIGHT });
+ * </script>
+ *
+ *
+ * @param items - a reference to a list of items to virtually scroll over.
+ * @param options - customises how the Virtual scroller list functions.
+ * @param options.itemHeight - the height in pixel or a function that returns the height in pixels for each item.
+ * @param options.overscan - number of pre-rendered DOM nodes. Prevents whitespace between items if you scroll very quickly.
+ * @param options.prefixHeight - the prefix height of elements present the scrollable area but not present in the items property.
+ * @param options.disabled - if set to true, disables the virtual scrolling functionality.
+ */
 export declare function useVirtualList<T>(items: Ref<T[]>, { disabled, itemHeight, overscan, prefixHeight }: UseVirtualListOptions): {
     containerRef: Ref<HTMLElement>;
     containerProps: UseVirtualListContainerProps;

package/dist/@types/packages/vue2/src/composables/useDynamicImport.d.ts

@@ -1,2 +1,8 @@
 import { MaybeRef } from "../types";
+/**
+ * Dynamic import fn, check if this is even possible?????
+ * @param packageName
+ * @param suffixSvgSrc
+ * @param fallBackSrc
+ */
 export declare const useDynamicIconImport: (packageName: string, suffixSvgSrc: MaybeRef<string>, fallBackSrc: string) => import("../../../vue3/node_modules/vue").Ref<string>;

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

@@ -1,3 +1,11 @@
 import type { MaybeElementRef } from "../../types";
 import type { OnClickOutsideHandler, OnClickOutsideOptions } from './types';
+/**
+ * Listen for clicks outside of an element.
+ *
+ * @see https://vueuse.org/onClickOutside
+ * @param target
+ * @param handler
+ * @param options
+ */
 export declare function onClickOutside<T extends OnClickOutsideOptions>(target: MaybeElementRef, handler: OnClickOutsideHandler, options?: T): () => void;

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

@@ -1,7 +1,18 @@
 import type { MaybeElementRef } from "../../types";
 export interface OnClickOutsideOptions {
+    /**
+     * List of elements that should not trigger the event.
+     */
     ignore?: (MaybeElementRef | string)[];
+    /**
+     * Use capturing phase for internal event listener.
+     * @default true
+     */
     capture?: boolean;
+    /**
+     * Run handler function if focus moves to an iframe.
+     * @default false
+     */
     detectIframe?: boolean;
     window?: Window;
 }

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

@@ -1,7 +1,61 @@
 import type { Fn, MaybeComputedRef } from "../../../types";
 import type { Arrayable, GeneralEventListener } from './types';
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 1: Omitted Window target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param event
+ * @param listener
+ * @param options
+ */
 export declare function useEventListener<E extends keyof WindowEventMap>(event: Arrayable<E>, listener: Arrayable<(this: Window, ev: WindowEventMap[E]) => unknown>, options?: MaybeComputedRef<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 2: Explicitly Window target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
 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;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 3: Explicitly Document target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
 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;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 4: Custom event target with event type infer
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
 export declare function useEventListener<Names extends string, EventType = Event>(target: EventTarget, event: Arrayable<Names>, listener: Arrayable<GeneralEventListener<EventType>>, options?: MaybeComputedRef<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 5: Custom event target fallback
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
 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/packages/vue2/src/directives/click-outside/utils.d.ts

@@ -1,6 +1,14 @@
 import type { MaybeComputedElementRef, MaybeElement } from "../../types";
 export declare const defaultWindow: Window & typeof globalThis;
 export declare const isIOS: boolean;
+/**
+ * Get the value of value/ref/getter.
+ */
 export declare function resolveUnref<T>(r: any): T;
+/**
+ * Get the dom element of a ref of element or Vue component instance
+ *
+ * @param elRef
+ */
 export declare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): any;
 export declare const noop: () => void;

package/dist/@types/packages/vue2/src/directives/tooltip/tooltip.d.ts

@@ -1,3 +1,29 @@
+/**
+ * This directive allows you to bind a tooltip to an element.
+ * Tooltip can be configured to be shown in one of four positions: 'top', 'left', 'right' and 'bottom'.
+ *
+ * @example
+ * import { BentoTooltipDirective as BentoTooltip, BentoTooltipPosition } from '@adyen/bento-vue2';
+ *
+ * export default {
+ *     directives: { BentoTooltip },
+ *     methods: {
+ *         contentExpression() {
+ *             return 'tooltip content';
+ *         },
+ *     },
+ *     template: `<div>
+ *         <div v-bento-tooltip:left="refToTooltipContent"></div>
+ *         <div v-bento-tooltip:[TooltipPosition.BOTTOM]="refToTooltipContent"></div>
+ *
+ *         <!-- If you don't specify the position then by default it's `TooltipPosition.TOP` -->
+ *         <div v-bento-tooltip="refToTooltipContent"></div>
+ *
+ *         <!-- Tooltip content can also be a data property or a method or a computed property as well -->
+ *         <div v-bento-tooltip="contentExpression()"></div>
+ *     </div>`,
+ * };
+ */
 export declare const BentoTooltipDirective: {
     bind(el: any, binding: any): void;
     update(el: any, binding: any): void;

package/dist/@types/packages/vue2/src/templates/data-grid-template/data-grid-template.vue.d.ts

@@ -1,6 +1,32 @@
 import { PropType } from "../../../../vue3/node_modules/vue";
 import type { BentoDataGridTemplateTabs } from './data-grid-template.types';
+/**
+ * The data grid template is a restrictive, full-page data grid used to display information from a data set.
+ * You can use this data grid template when your user needs a clear overview of data or a way of organizing and analyzing the data in their own way.
+ * This data grid template shouldn’t be confused with the data grid.
+ *
+ * @example
+ * import { BentoDataGridTemplate } from '@adyen/bento-vue2';
+ *
+ * export default {
+ *     components: { BentoDataGridTemplate },
+ *     template: `
+ *          // If you want to display multiple data grids in the same page (they will be rendered in different tabs)
+ *          <bento-data-grid-template>
+ *              <template #tab-1><bento-data-grid v-bind="your-data-grid-args" title="Title for tab 1"/></template>
+ *              <template #tab-2><bento-data-grid v-bind="your-data-grid-args" title="Title for tab 2"/></template>
+ *          </bento-data-grid-template>
+ *          // Alternatively, if you only want to pass one data grid to your template:
+ *          <bento-data-grid-template>
+ *              <template #default><bento-data-grid v-bind="your-data-grid-args"/></template>
+ *          </bento-data-grid-template>
+ *     `
+ * }
+ */
 declare const _default: __VLS_WithTemplateSlots<import("../../../../vue3/node_modules/vue").DefineComponent<{
+    /**
+     * The header that goes to the top of the template
+     */
     header: {
         type: PropType<Partial<{
             variant: "component" | "page" | import("../../components/header/header.types").BentoHeaderVariant;
@@ -38,15 +64,26 @@ declare const _default: __VLS_WithTemplateSlots<import("../../../../vue3/node_mo
         }>> & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "variant" | "actions" | "infoIconTooltipText" | "lastUpdated" | "infoIconPopoverPosition">>;
         required: true;
     };
+    /**
+     * All the tab properties that can be set on the inner tab components.
+     *  - tabs.activeTabIndex: the currently active tab index.
+     *  - tabs.tabs: an array of BentoTab props, the first item in the array will affect the `tab-1` slot and so on.
+     */
     tabs: {
         type: PropType<BentoDataGridTemplateTabs>;
         default: any;
     };
+    /**
+     * Renders the tabs with a sticky positioning
+     */
     stickyTabs: {
         type: BooleanConstructor;
         default: boolean;
     };
 }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {}, string, import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+    /**
+     * The header that goes to the top of the template
+     */
     header: {
         type: PropType<Partial<{
             variant: "component" | "page" | import("../../components/header/header.types").BentoHeaderVariant;
@@ -84,10 +121,18 @@ declare const _default: __VLS_WithTemplateSlots<import("../../../../vue3/node_mo
         }>> & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "variant" | "actions" | "infoIconTooltipText" | "lastUpdated" | "infoIconPopoverPosition">>;
         required: true;
     };
+    /**
+     * All the tab properties that can be set on the inner tab components.
+     *  - tabs.activeTabIndex: the currently active tab index.
+     *  - tabs.tabs: an array of BentoTab props, the first item in the array will affect the `tab-1` slot and so on.
+     */
     tabs: {
         type: PropType<BentoDataGridTemplateTabs>;
         default: any;
     };
+    /**
+     * Renders the tabs with a sticky positioning
+     */
     stickyTabs: {
         type: BooleanConstructor;
         default: boolean;

package/dist/@types/packages/vue2/src/types/elements.d.ts

@@ -2,7 +2,35 @@ import type { ComponentPublicInstance } from "../../../vue3/node_modules/vue";
 import { MaybeComputedRef, MaybeRef } from './refs';
 export type VueInstance = ComponentPublicInstance;
 export type Component = object;
+/**
+ * Vue node element instance
+ *
+ * ```ts
+ * type Vue | Element | (Vue | Element)[] | undefined
+ * ```
+ */
 export type VueNodeElement = Component | Element | (Component | Element)[] | undefined;
+/**
+ * Maybe it's an Element (HTML, SVG, VueNode).
+ *
+ * ```ts
+ * type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null
+ * ```
+ */
 export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
+/**
+ * Maybe it's an Element (HTML, SVG, VueNode) `ref`.
+ *
+ * ```ts
+ * type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>
+ * ```
+ */
 export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
+/**
+ * Maybe it's a computed Element (HTML, SVG, VueNode) `ref`.
+ *
+ * ```ts
+ * type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeComputedRef<T>
+ * ```
+ */
 export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeComputedRef<T>;

package/dist/@types/packages/vue2/src/types/functions.d.ts

@@ -1,2 +1,8 @@
+/**
+ * Void function
+ */
 export type Fn = () => void;
+/**
+ * Any function
+ */
 export type AnyFn<T> = (...args: T[]) => T;

package/dist/@types/packages/vue2/src/types/listbox.d.ts

@@ -24,13 +24,22 @@ export declare enum BentoListboxEvent {
     TAB = "tab-pressed",
     CLOSE_DROPDOWN = "close-dropdown"
 }
+/**
+ * @deprecated for usage with properties since version 2.0. Use the string literal instead.
+ */
 export declare enum BentoListboxLazyLoadType {
     AUTOMATIC = "automatic",
     BUTTON = "button",
     NONE = "none"
 }
 export interface BentoListboxSearchOptions {
+    /**
+     * Custom debounce time. Default: 300
+     */
     debounceTime?: number;
+    /**
+     * The event that triggers upon user filtering the listbox items.
+     */
     searchEvent: (searchValue: string) => void;
 }
 export type BentoListboxEmptyStateProps = {

package/dist/@types/packages/vue2/src/types/maybe-ref.d.ts

@@ -1,2 +1,7 @@
 import { Ref } from "../../../vue3/node_modules/vue";
+/**
+ * As recommmended by the vue community to use this type when you are not sure
+ * if the argument is a ref.
+ * Source: https://github.com/vueuse/vueuse/blob/main/packages/shared/utils/types.ts#L28
+ */
 export type MaybeRef<T> = T | Ref<T>;

package/dist/@types/packages/vue2/src/types/refs.d.ts

@@ -1,4 +1,30 @@
 import { ComputedRef, Ref } from "../../../vue3/node_modules/vue";
+/**
+ *
+ * Maybe it's a `ref`, or a plain value.
+ *
+ * As recommmended by the vue community to use this type when you are not sure
+ * if the argument is a ref.
+ * Source: https://github.com/vueuse/vueuse/blob/main/packages/shared/utils/types.ts#L28
+ *
+ * ```ts
+ * type MaybeRef<T> = T | Ref<T>
+ * ```
+ */
 export type MaybeRef<T> = T | Ref<T>;
+/**
+ * Maybe it's a computed ref, or a getter function
+ *
+ * ```ts
+ * type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>
+ * ```
+ */
 export type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;
+/**
+ * Maybe it's a ref, or a plain value, or a getter function
+ *
+ * ```ts
+ * type MaybeComputedRef<T> = (() => T) | T | Ref<T> | ComputedRef<T>
+ * ```
+ */
 export type MaybeComputedRef<T> = MaybeReadonlyRef<T> | MaybeRef<T>;

package/dist/@types/packages/vue2/src/types/utils-events.d.ts

@@ -18,6 +18,9 @@ export declare enum EventKey {
     END = "End",
     HOME = "Home"
 }
+/**
+ * @deprecated `Event.keyCode` is deprecated. Use `EventKey` instead
+ */
 export declare enum KeyCode {
     ESCAPE = 27,
     ENTER = 13,

package/dist/@types/packages/vue2/src/utils/ts/aria-label.d.ts

@@ -5,5 +5,12 @@ interface ariaLabelOptions {
     label?: MaybeRef<string | null>;
     defaultFallback?: MaybeRef<string | null>;
 }
+/**
+ * Returns a valid aria-label for the element it's invoked for
+ * @param ariaLabel - The aria label, which has to be set manually through the homonymous prop
+ * @param label - Any other label provided, usually the component's main text
+ * @param defaultFallback - The default fallback if no other value is provided
+ * @returns {string | null} - A string corresponding to the aria label or null if no value is provided
+ */
 export declare const useAriaLabel: ({ ariaLabel, label, defaultFallback, }: ariaLabelOptions) => ComputedRef<string>;
 export {};

package/dist/@types/packages/vue2/src/utils/ts/currency/countries-list.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Contains mapping configuration between currency code and exponent for amount in the corresponding currency.
+ * Since the majority of the currencies have an exponent equal to 2, they are not listed here.
+ * https://docs.adyen.com/development-resources/currency-codes
+ * @type {Array}
+ * @internal
+ */
 export declare const currencyExponentMap: {
     exponent: number;
     currencies: string[];

package/dist/@types/packages/vue2/src/utils/ts/currency/currency.d.ts

@@ -1,6 +1,35 @@
 import { CurrencyAmount, CurrencyOptions, NumberFormatOptionsResult } from './currency.types';
+/**
+ * Returns exponent for specified currency code.
+ */
 export declare const getExponent: (currencyCode: string) => number;
+/**
+ * Converts passed amount from regular to minor units, based on currency exponent
+ */
 export declare const getMinorUnitsAmount: (amount: CurrencyAmount) => number;
+/**
+ * Returns normalized amount value from minor units as decimal point number (when exponent is more than zero).
+ */
 export declare const getNormalizedAmount: (amount: CurrencyAmount, exponent: number) => number;
+/**
+ * /**
+ * Prepares amount to be rendered by Intl.NumberFormat function.
+ * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+ *
+ * It enables language-sensitive number formatting.
+ * Adds currency symbol and ISO code based on provided options
+ * The result of execution - is a configuration object that is used in 'getLocalizedCurrencyValue' function
+ *
+ * @param amount - the value and currency to format.
+ * @param options - the formatting options that are passed to the Intl.NumberFormat function.
+ * @param majorUnits - if set to true, then currency major units will be used instead of minor ones
+ */
 export declare function getNumberFormatOptions(amount: CurrencyAmount, options?: CurrencyOptions, majorUnits?: boolean): NumberFormatOptionsResult;
+/**
+ * Get a formatted and localised currency string given an amount and currency type.
+ *
+ * @param amountValue - the amount of the currency.
+ * @param currency - the ISO 4217 currency code.
+ * @param majorUnits - if set to true, then currency major units will be used instead of minor ones
+ */
 export declare const getLocalizedCurrencyValue: (amountValue: string, currency: string, majorUnits?: boolean) => string;

package/dist/@types/packages/vue2/src/utils/ts/debounce/debounce.d.ts

@@ -1 +1,10 @@
+/**
+ * The debounce() method is used to create a debounced function which
+ * delays the given callback function until after the stated wait time
+ * in milliseconds have passed since the last time this debounced function was called.
+ *
+ * @param {Function} callback - The function to debounce.
+ * @param debounceTime - The number of milliseconds to delay.
+ * @returns {Function} - Returns the new debounced function.
+ */
 export declare const debounce: <T extends (...args: any[]) => any>(callback: T, debounceTime?: number) => T;

package/dist/@types/packages/vue2/src/utils/ts/deprecate.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Informs users about the deprecations in development mode only.
+ *
+ * @param title Indicates what is being deprecated.
+ * @param deprecationMessage How to avoid the deprecation by giving an example of the alternatives. Backticks can be used to multi-line the message.
+ * @param toBeRemovedInVersion The version it will be removed. Must be in X.Y.Z format.
+ */
 export declare function deprecate(title: string, deprecationMessage: string, toBeRemovedInVersion: string): void;
+/**
+ * Reset shownMessages set
+ *
+ * @deprecated For testing purposes only. Do not use.
+ */
 export declare function resetShownMessages(): void;

package/dist/@types/packages/vue2/src/utils/ts/events.d.ts

@@ -1,3 +1,22 @@
 import { ListenOptions } from "../../types/utils-events";
+/**
+ * Attach event listeners using options object (implementing browser fallbacks), easy cleanup
+ *
+ * @param {EventTarget}  target              - Target where the event will be attached
+ * @param {string}       type                - Event type(s). Accepts multiple types separated by space
+ * @param {EventHandler} listener            - Handler function
+ * @param {ListenOptions}[options]           - Listener options
+ * @param {boolean}      [options.capture]   - Capture event listener
+ * @param {boolean}      [options.passive]   - Passive event listener
+ * @param {boolean}      [options.once]      - Auto cleanup after event is fired for the first time
+ * @param {boolean}      [options.self]      - Only trigger if the target of the event is itself
+ * @param {Vue}          [options.vm]        - Auto cleanup when vue instance is destroyed
+ * @param {Function}     [options.onCleanup] - Callback function invoked after cleaning up
+ * @return {Function} Cleanup function that removes the listener
+ */
 export declare function listen(target: EventTarget, type: string, listener: EventListener, options?: ListenOptions): any;
+/**
+ * Prevents the event from bubbling
+ * @param {Event} event - Triggered event
+ */
 export declare const stopEventPropagation: (event: Event) => void;

package/dist/@types/packages/vue2/src/utils/ts/focus-trap.utils.d.ts

@@ -1,8 +1,33 @@
 import { BentoFocusTrapHorizontalNavigationEvent, BentoFocusTrapVerticalNavigationEvent } from "../../components/focus-trap/focus-trap.types";
+/**
+ * Perform callback before next re-paint frame of browser.
+ *
+ * @param action
+ * @returns
+ */
 export declare const deferAction: (callback: FrameRequestCallback) => number;
+/**
+ * Retrieves the next focusable element using a factor to either choose
+ * the next or previous focusable element.
+ *
+ * @param factor a number +1 or -1
+ * @param element the element to checks for focusable elements inside of
+ * @returns
+ */
 export declare const getNextFocusableElement: (factor: any, element: any) => HTMLElement;
+/**
+ * Returns an object is if keyboard event key is an arrow previous or next key.
+ * this changes depending on if the arrow navigation is horizontal or vertical.
+ *
+ * @param event
+ * @param arrowOrder
+ * @returns { isArrowNext: boolean, isArrowPrev: boolean }
+ */
 export declare const getArrowType: (event: KeyboardEvent, arrowOrder: BentoFocusTrapVerticalNavigationEvent[] | BentoFocusTrapHorizontalNavigationEvent[]) => {
     isArrowNext: boolean;
     isArrowPrev: boolean;
 };
+/**
+ * Default scrolling into view options
+ */
 export declare const SCROLL_INTO_VIEW_OPTIONS: ScrollIntoViewOptions;

package/dist/@types/packages/vue2/src/utils/ts/get-slot-text/get-slot-text.d.ts

@@ -1,3 +1,9 @@
 import type { Slots } from "../../../../../vue3/node_modules/vue";
+/**
+ * Get text recursively from slot by giving slot name.
+ * This recursion will only occur 5 times before the method gives up and returns an empty string.
+ * @param slots - the slots provided the the component's setup function
+ * @returns A function who's first parameter is the name of the slot.
+ */
 export declare const getSlotText: (slots: Slots) => (name: string) => string;
 export default getSlotText;