@adyen/kyc-components 2.2.3 → 2.2.5

package/dist/types/components/internal/FormFields/Field/Field.d.ts

@@ -0,0 +1,11 @@
+import './Field.scss';
+import { ComponentProps } from 'preact';
+import { FC } from 'preact/compat';
+import { FieldProps } from './types';
+export type MaybeLabelElementProps = (ComponentProps<'label'> & {
+    useLabelElement: true;
+}) | (ComponentProps<'div'> & {
+    useLabelElement: false;
+});
+declare const Field: FC<FieldProps>;
+export default Field;

package/dist/types/components/internal/FormFields/Field/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Field';

package/dist/types/components/internal/FormFields/Field/types.d.ts

@@ -0,0 +1,33 @@
+import { ComponentChildren } from 'preact';
+import { ChangeEventHandler } from 'preact/compat';
+import { TranslationKey } from '../../../../language/types';
+export interface FieldChildProps {
+    isInvalid: boolean;
+    isValid: boolean;
+    onBlurHandler: ChangeEventHandler<EventTarget>;
+    onFocusHandler: ChangeEventHandler<EventTarget>;
+    uniqueId: string;
+}
+export interface FieldProps {
+    children: (props: FieldChildProps) => ComponentChildren;
+    className?: string;
+    classNameModifiers?: string[];
+    dataPlaceholder?: string;
+    disabled?: boolean;
+    dualBrandingElements?: any;
+    errorMessage?: TranslationKey | string | boolean | null;
+    filled?: boolean;
+    focused?: boolean;
+    helper?: string;
+    inputWrapperModifiers?: string[];
+    isLoading?: boolean;
+    isValid?: boolean;
+    label?: string;
+    name: string;
+    onBlur?: ChangeEventHandler<EventTarget>;
+    onFieldBlur?: ChangeEventHandler<EventTarget>;
+    onFocus?: ChangeEventHandler<EventTarget>;
+    onFocusField?: ChangeEventHandler<EventTarget>;
+    showErrorIconBottom?: boolean;
+    useLabelElement?: boolean;
+}

package/dist/types/components/internal/FormFields/InputBase.d.ts

@@ -0,0 +1,25 @@
+import './FormFields.scss';
+import { ComponentProps, JSX } from 'preact';
+export interface InputBaseProps extends ComponentProps<'input'> {
+    autoCorrect?: string;
+    classNameModifiers?: string[];
+    isInvalid?: boolean;
+    isValid?: boolean;
+    readonly?: boolean;
+    maxLength?: number;
+    spellCheck?: boolean;
+    type?: string;
+    disabled?: boolean;
+    uniqueId?: string;
+    className?: string;
+    trimOnBlur?: boolean;
+    onInput?: (event: JSX.TargetedEvent<HTMLInputElement>) => void;
+    onBlur?: (event: JSX.TargetedFocusEvent<HTMLInputElement>) => void;
+    onBlurHandler?: (event: JSX.TargetedFocusEvent<HTMLInputElement>) => void;
+    onFocusHandler?: (event: JSX.TargetedFocusEvent<HTMLInputElement>) => void;
+    onChange?: never;
+}
+declare const InputBase: import("preact").FunctionalComponent<Omit<InputBaseProps, "ref"> & {
+    ref?: import("preact").Ref<HTMLInputElement>;
+}>;
+export default InputBase;

package/dist/types/components/internal/FormFields/InputDate/InputDate.d.ts

@@ -0,0 +1,7 @@
+import { JSX } from 'preact';
+import { InputBaseProps } from '../InputBase';
+interface InputDateProps extends InputBaseProps {
+    onInput: (e: JSX.TargetedEvent<HTMLInputElement>) => void;
+}
+export default function InputDate(props: InputDateProps): JSX.Element;
+export {};

package/dist/types/components/internal/FormFields/InputDate/index.d.ts

@@ -0,0 +1 @@
+export { default } from './InputDate';

package/dist/types/components/internal/FormFields/InputDate/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns either the date input is supported or not in the current browser
+ */
+declare const checkDateInputSupport: () => boolean;
+/**
+ * Returns a formatted date
+ * @param value -
+ * @example
+ * formatDate('22111990');
+ * // '22/11/1990'
+ */
+declare const formatDate: (value: string) => string;
+/**
+ * Receives a formatted date and returns it as the API expects it
+ * @param value -
+ * @example
+ * unformatDate('22/11/1990');
+ * // '1990-11-22'
+ */
+declare const unformatDate: (value?: string) => string;
+declare const formatDateObj: (date: Date) => string;
+export { checkDateInputSupport, formatDate, formatDateObj, unformatDate };

package/dist/types/components/internal/FormFields/InputEmail.d.ts

@@ -0,0 +1 @@
+export default function InputEmail(props: any): import("preact").JSX.Element;

package/dist/types/components/internal/FormFields/InputRadio/InputRadio.d.ts

@@ -0,0 +1,6 @@
+import './_input-radio.scss';
+import { ComponentProps } from 'preact';
+export declare const InputRadio: ({ className, ...props }: import("preact").JSX.HTMLAttributes<HTMLInputElement> & {
+    className?: string;
+}) => import("preact").JSX.Element;
+export default InputRadio;

package/dist/types/components/internal/FormFields/InputTelephone.d.ts

@@ -0,0 +1 @@
+export default function InputTelephone(props: any): import("preact").JSX.Element;

package/dist/types/components/internal/FormFields/InputText.d.ts

@@ -0,0 +1,8 @@
+import { InputBaseProps } from './InputBase';
+interface InputTextProps extends InputBaseProps {
+    transformInput?: (input: string) => string;
+}
+declare const InputText: import("preact").FunctionalComponent<Omit<InputTextProps, "ref"> & {
+    ref?: import("preact").Ref<HTMLInputElement>;
+}>;
+export default InputText;

package/dist/types/components/internal/FormFields/MultiSelectList/MultiSelectList.d.ts

@@ -0,0 +1,9 @@
+import { SelectItem } from '../Select/types';
+interface MultiSelectListProps<OptionType> {
+    options: readonly OptionType[];
+    selected: OptionType[];
+    onSelect: (options: OptionType[]) => void;
+    mapToSelectItem: (option: OptionType) => SelectItem;
+}
+export declare const MultiSelectList: <OptionType>({ options, selected, onSelect, mapToSelectItem, }: MultiSelectListProps<OptionType>) => import("preact").JSX.Element;
+export {};

package/dist/types/components/internal/FormFields/MultiSelectList/index.d.ts

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

package/dist/types/components/internal/FormFields/RadioGroup/RadioGroup.d.ts

@@ -0,0 +1,10 @@
+import './RadioGroup.scss';
+import { RadioGroupProps } from './types';
+declare function RadioGroup({ items, i18n, name, onChange, value, isInvalid, uniqueId, className, disabled, }: RadioGroupProps): import("preact").JSX.Element;
+declare namespace RadioGroup {
+    var defaultProps: {
+        onChange: () => void;
+        items: any[];
+    };
+}
+export default RadioGroup;

package/dist/types/components/internal/FormFields/RadioGroup/index.d.ts

@@ -0,0 +1 @@
+export { default } from './RadioGroup';

package/dist/types/components/internal/FormFields/RadioGroup/types.d.ts

@@ -0,0 +1,18 @@
+import Language from '../../../../language/Language';
+import { TranslationKey } from '../../../../language/types';
+interface RadioGroupItem {
+    name: TranslationKey;
+    id: string;
+}
+export interface RadioGroupProps {
+    className?: string;
+    isInvalid?: boolean;
+    items: RadioGroupItem[];
+    i18n: Language;
+    name?: string;
+    onChange: (e: any) => void;
+    value?: string;
+    uniqueId?: string;
+    disabled?: boolean;
+}
+export {};

package/dist/types/components/internal/FormFields/RadioGroupCard/RadioCard.d.ts

@@ -0,0 +1,3 @@
+import './RadioCard.scss';
+import { RadioCardProps } from './types';
+export declare const RadioCard: ({ optionId, optionName, optionDescription, optionSubtitle, name, uniqueId, isInvalid, isSelected, onSelect, labelClassName, className, disabled, icon, body, footer, }: RadioCardProps) => import("preact").JSX.Element;

package/dist/types/components/internal/FormFields/RadioGroupCard/RadioCardSelect.d.ts

@@ -0,0 +1,22 @@
+import './RadioGroupCard.scss';
+import { ComponentChildren } from 'preact';
+import { TranslationKey } from '../../../../language/types';
+export interface RadioCardSelectProps<OptionType> {
+    className?: string;
+    isInvalid?: boolean;
+    options: readonly OptionType[];
+    name?: string;
+    onSelect: (option: OptionType) => void;
+    selected: OptionType | undefined;
+    uniqueId?: string;
+    isOptionDisabled?: (option: OptionType) => boolean;
+    optionId: (option: OptionType) => string;
+    optionName: (option: OptionType) => TranslationKey;
+    optionDescription: (option: OptionType) => TranslationKey;
+    optionSubtitle?: (option: OptionType) => TranslationKey | undefined;
+    renderOptionIcon?: (option: OptionType) => ComponentChildren;
+    renderOptionBody?: (option: OptionType) => ComponentChildren;
+    renderOptionFooter?: (option: OptionType) => ComponentChildren;
+    optionLabelClassName?: (option: OptionType) => string;
+}
+export declare function RadioCardSelect<OptionType>({ options, name, onSelect, selected, isInvalid, uniqueId, className, optionId, optionName, optionDescription, optionSubtitle, optionLabelClassName, renderOptionIcon, renderOptionBody, renderOptionFooter, isOptionDisabled, }: RadioCardSelectProps<OptionType>): import("preact").JSX.Element;

package/dist/types/components/internal/FormFields/RadioGroupCard/RadioGroupCard.d.ts

@@ -0,0 +1,3 @@
+import './RadioGroupCard.scss';
+import { RadioGroupCardProps } from './types';
+export declare function RadioGroupCard({ items, name, onSelect, selected, isInvalid, uniqueId, className, itemLabelClassName, itemIcon, itemBody, itemFooter, isItemDisabled, }: RadioGroupCardProps): import("preact").JSX.Element;

package/dist/types/components/internal/FormFields/RadioGroupCard/index.d.ts

@@ -0,0 +1,3 @@
+export * from './RadioCard';
+export * from './RadioCardSelect';
+export * from './RadioGroupCard';

package/dist/types/components/internal/FormFields/RadioGroupCard/types.d.ts

@@ -0,0 +1,40 @@
+import { ComponentChildren } from 'preact';
+import { TranslationKey } from '../../../../language/types';
+export interface RadioGroupCardItem {
+    name: TranslationKey;
+    description: TranslationKey;
+    id: string;
+    subtitle?: TranslationKey;
+}
+export interface RadioGroupCardProps {
+    className?: string;
+    isInvalid?: boolean;
+    readonly?: boolean;
+    items: readonly RadioGroupCardItem[];
+    name?: string;
+    onSelect: (item: RadioGroupCardItem) => void;
+    selected: RadioGroupCardItem | undefined;
+    uniqueId?: string;
+    isItemDisabled?: (item: RadioGroupCardItem) => boolean;
+    itemIcon?: (item: RadioGroupCardItem) => ComponentChildren;
+    itemFooter?: (item: RadioGroupCardItem) => ComponentChildren;
+    itemBody?: (item: RadioGroupCardItem) => ComponentChildren;
+    itemLabelClassName?: (item: RadioGroupCardItem) => string;
+}
+export interface RadioCardProps {
+    optionId: string;
+    optionName: TranslationKey;
+    optionDescription: TranslationKey;
+    optionSubtitle?: TranslationKey;
+    name?: string;
+    className?: string;
+    uniqueId: string;
+    isInvalid?: boolean;
+    isSelected: boolean;
+    onSelect: () => void;
+    labelClassName?: string;
+    disabled?: boolean;
+    icon?: ComponentChildren;
+    footer?: ComponentChildren;
+    body?: ComponentChildren;
+}

package/dist/types/components/internal/FormFields/Select/Select.d.ts

@@ -0,0 +1,5 @@
+import './Select.scss';
+import { JSX } from 'preact';
+import { SelectProps } from './types';
+declare const Select: ({ items, className, classNameModifiers, filterable, readonly, onChange, selected, name, isInvalid, isValid, placeholder, isMulti, uniqueId, showSelectedItemsAsTags, isSearch, onSearch, resetSearch, loading, getSearchItem, searchText, showSearchList, }: SelectProps) => JSX.Element;
+export default Select;

package/dist/types/components/internal/FormFields/Select/components/SelectButton.d.ts

@@ -0,0 +1,3 @@
+import { SelectButtonProps } from '../types';
+declare function SelectButton({ active, readonly, showList, isInvalid, isValid, toggleList, onButtonKeyDown, filterable, placeholder, toggleButtonRef, ariaDescribedBy, selectListId, filterInputRef, onInput, isMulti, id, isSearch, loading, textFilter, }: SelectButtonProps): import("preact").JSX.Element;
+export default SelectButton;

package/dist/types/components/internal/FormFields/Select/components/SelectList.d.ts

@@ -0,0 +1,3 @@
+import { SelectListProps } from '../types';
+declare function SelectList({ active, items, showList, textFilter, isMulti, showAbove, isSearch, loading, getSearchItem, ...props }: SelectListProps): import("preact").JSX.Element;
+export default SelectList;

package/dist/types/components/internal/FormFields/Select/components/SelectListItem.d.ts

@@ -0,0 +1,3 @@
+import { SelectItemProps } from '../types';
+declare const SelectListItem: ({ item, selected, isMulti, isSearch, children, onSelect, onKeyDown, className, }: SelectItemProps) => import("preact").JSX.Element;
+export default SelectListItem;

package/dist/types/components/internal/FormFields/Select/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Select';

package/dist/types/components/internal/FormFields/Select/types.d.ts

@@ -0,0 +1,127 @@
+import { ComponentChild, JSX } from 'preact';
+import { MutableRef } from 'preact/hooks';
+export interface SelectItem {
+    disabled?: boolean;
+    icon?: string;
+    sprite?: string;
+    id: string;
+    name: string;
+    description?: string;
+    selectedOptionName?: string;
+    className?: string;
+}
+export interface AddressSpecificSelectItem extends SelectItem {
+    text?: string;
+    type?: string;
+    addressAmount?: string;
+    highlight?: string;
+}
+interface BaseSelectProps {
+    className?: string;
+    classNameModifiers?: string[];
+    filterable?: boolean;
+    isInvalid?: boolean;
+    items: SelectItem[];
+    name?: string;
+    placeholder: string;
+    readonly?: boolean;
+    selected: string | string[] | undefined;
+    isValid?: boolean;
+    uniqueId?: string;
+    showSelectedItemsAsTags?: boolean;
+    isSearch?: boolean;
+    onSearch?: (text: string) => void;
+    resetSearch?: boolean;
+    loading?: boolean;
+    getSearchItem?: (item: SelectItem) => ComponentChild;
+    searchText?: string;
+    showSearchList?: boolean;
+}
+interface SingleSelectProps extends BaseSelectProps {
+    isMulti?: false;
+    onChange: (e: {
+        target: {
+            value: SelectItem['id'];
+            name: string;
+        };
+    }) => void;
+}
+interface MultiSelectProps extends BaseSelectProps {
+    isMulti: true;
+    onChange: (e: {
+        target: {
+            value: Array<SelectItem['id']>;
+            name: string;
+        };
+    }) => void;
+}
+export type SelectProps = SingleSelectProps | MultiSelectProps;
+export interface SelectButtonProps {
+    active: SelectItem[];
+    filterInputRef: MutableRef<HTMLInputElement>;
+    filterable: boolean;
+    isInvalid: boolean;
+    onButtonKeyDown: (e: KeyboardEvent) => void;
+    onInput: (e: JSX.TargetedEvent<HTMLInputElement, Event>) => void;
+    placeholder: string;
+    readonly: boolean;
+    selectListId: string;
+    showList: boolean;
+    toggleButtonRef: MutableRef<HTMLButtonElement>;
+    toggleList: (e: Event) => void;
+    isValid?: boolean;
+    ariaDescribedBy: string;
+    isMulti: boolean;
+    id?: string;
+    showSelectedItemsAsTags?: boolean;
+    isSearch?: boolean;
+    loading?: boolean;
+    textFilter?: string;
+}
+export interface SelectListProps {
+    active: SelectItem[];
+    items: SelectItem[];
+    onKeyDown: (e: JSX.TargetedKeyboardEvent<HTMLLIElement>, item: SelectItem) => void;
+    onSelect: (item: SelectItem) => void;
+    selectListId: string;
+    selectListRef: MutableRef<HTMLUListElement>;
+    showList: boolean;
+    textFilter: string;
+    isMulti: boolean;
+    showAbove?: boolean;
+    isSearch?: boolean;
+    loading?: boolean;
+    getSearchItem?: (item: AddressSpecificSelectItem) => ComponentChild;
+}
+export interface SelectItemProps {
+    item: SelectItem;
+    selected: boolean;
+    onKeyDown: (e: JSX.TargetedKeyboardEvent<HTMLLIElement>) => void;
+    onSelect: (selected: boolean) => void;
+    isMulti: boolean;
+    isSearch?: boolean;
+    children?: ComponentChild;
+    className?: string;
+}
+export interface SelectButtonContentSingleProps {
+    active: SelectItem[];
+    filterInputRef: MutableRef<HTMLInputElement>;
+    filterable: boolean;
+    onInput: (e: JSX.TargetedEvent<HTMLInputElement, Event>) => void;
+    placeholder: string;
+    selectListId: string;
+    showList: boolean;
+    showSelectedItemsAsTags?: boolean;
+    isSearch?: boolean;
+    loading?: boolean;
+    textFilter?: string;
+}
+export interface SelectButtonContentMultiProps {
+    active: SelectItem[];
+    placeholder: string;
+}
+export default interface SelectedItemsAsTagsProps {
+    active: SelectItem[];
+    isMulti?: boolean;
+}
+export {};

package/dist/types/components/internal/FormFields/TextArea.d.ts

@@ -0,0 +1 @@
+export default function TextArea(props: any): import("preact").JSX.Element;

package/dist/types/components/internal/FormFields/utils.d.ts

@@ -0,0 +1,2 @@
+declare const convertFullToHalf: (str: any) => any;
+export { convertFullToHalf };

package/dist/types/components/internal/FormHeader/FormHeader.d.ts

@@ -0,0 +1,3 @@
+import './FormHeader.scss';
+import { FormHeaderProps } from './type';
+export declare function FormHeader({ heading, description, headingComponent, descriptionComponent, classNames, }: FormHeaderProps): import("preact").JSX.Element;

package/dist/types/components/internal/FormHeader/type.d.ts

@@ -0,0 +1,8 @@
+import { VNode } from 'preact';
+export interface FormHeaderProps {
+    heading?: string;
+    description?: string;
+    headingComponent?: VNode;
+    descriptionComponent?: VNode;
+    classNames?: string;
+}

package/dist/types/components/internal/Heading/Heading.d.ts

@@ -0,0 +1,10 @@
+import './_heading.component.scss';
+import { ComponentChildren } from 'preact';
+type HeadingLevel = 1 | 2 | 3 | 4 | 'sub';
+export interface HeadingProps {
+    children: ComponentChildren;
+    level: HeadingLevel;
+    className?: string;
+}
+export default function Heading({ className, level, children }: HeadingProps): import("preact").JSX.Element;
+export {};

package/dist/types/components/internal/Iban/Iban.d.ts

@@ -0,0 +1,3 @@
+import { IbanProps, IbanSchema } from './types';
+export declare const ibanFields: Array<keyof IbanSchema>;
+export default function Iban(props: IbanProps): import("preact").JSX.Element;

package/dist/types/components/internal/Iban/ibanValidator.d.ts

@@ -0,0 +1,4 @@
+import { ErrorMessage, FormatRules } from '../../../utils/validation/types';
+import { IbanSchema } from './types';
+export declare function ibanValidator(input: string | undefined | null, bankCountries: string[]): ErrorMessage | undefined;
+export declare const ibanFormatter: FormatRules<IbanSchema>;

package/dist/types/components/internal/Iban/index.d.ts

@@ -0,0 +1 @@
+export { default, ibanFields } from './Iban';

package/dist/types/components/internal/Iban/types.d.ts

@@ -0,0 +1,7 @@
+import type { BaseInnerFormProps } from '../../../core/hooks/useForm';
+export interface IbanSchema {
+    iban?: string;
+}
+export interface IbanProps extends BaseInnerFormProps<IbanSchema> {
+    country: string;
+}

package/dist/types/components/internal/Icon/Icon.d.ts

@@ -0,0 +1,8 @@
+import './_icon.scss';
+interface IconProps {
+    name: string;
+    className?: string;
+    testId?: string;
+}
+declare const Icon: ({ className, name, testId }: IconProps) => import("preact").JSX.Element;
+export default Icon;

package/dist/types/components/internal/Icon/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Icon';

package/dist/types/components/internal/LegalCompanyName/LegalCompanyName.d.ts

@@ -0,0 +1,3 @@
+import { LegalCompanyNameProps, LegalCompanyNameSchema } from './types';
+export declare const legalCompanyNameFields: Array<keyof LegalCompanyNameSchema>;
+export default function LegalCompanyName(props: LegalCompanyNameProps): import("preact").JSX.Element;

package/dist/types/components/internal/LegalCompanyName/index.d.ts

@@ -0,0 +1 @@
+export { default, legalCompanyNameFields } from './LegalCompanyName';

package/dist/types/components/internal/LegalCompanyName/types.d.ts

@@ -0,0 +1,8 @@
+import type { BaseInnerFormProps } from '../../../core/hooks/useForm';
+import type { CountryCode } from '../../../core/models/country-code';
+export interface LegalCompanyNameSchema {
+    legalCompanyName?: string;
+}
+export interface LegalCompanyNameProps extends BaseInnerFormProps<LegalCompanyNameSchema> {
+    country: CountryCode;
+}

package/dist/types/components/internal/LegalCompanyName/validate.d.ts

@@ -0,0 +1,3 @@
+import { ValidatorRules } from '../../../utils/validation/types';
+import { LegalCompanyNameSchema } from './types';
+export declare const companyNameValidatorRules: ValidatorRules<LegalCompanyNameSchema>;

package/dist/types/components/internal/Link/Link.d.ts

@@ -0,0 +1,5 @@
+import './_link.component.scss';
+import '../Button/_button.component.scss';
+import LinkProps from './types';
+declare const Link: ({ className, children, href, external, icon, underline, inheritStyles, showAsButton, iconLeft, onClick, }: LinkProps) => import("preact").JSX.Element;
+export default Link;

package/dist/types/components/internal/Link/index.d.ts

@@ -0,0 +1 @@
+export { default } from './Link';

package/dist/types/components/internal/Link/types.d.ts

@@ -0,0 +1,14 @@
+import classNames from 'classnames';
+import type { JSX } from 'preact/compat';
+export default interface LinkProps {
+    href: string;
+    external?: boolean;
+    icon?: string;
+    className?: classNames.Argument;
+    children: string | HTMLElement | JSX.Element;
+    showAsButton?: boolean;
+    inheritStyles?: boolean;
+    underline?: boolean;
+    iconLeft?: boolean;
+    onClick?: JSX.MouseEventHandler<HTMLAnchorElement>;
+}

package/dist/types/components/internal/List/List.d.ts

@@ -0,0 +1,4 @@
+import './_list.component.scss';
+import { ListProps } from './types';
+declare function List({ className, nested, ordered, noMarkers, children }: ListProps): import("preact").JSX.Element;
+export default List;

package/dist/types/components/internal/List/ListItem.d.ts

@@ -0,0 +1,3 @@
+import { ListItemProps } from './types';
+declare function ListItem({ className, children, noMarkers }: ListItemProps): import("preact").JSX.Element;
+export default ListItem;

package/dist/types/components/internal/List/types.d.ts

@@ -0,0 +1,13 @@
+import { ComponentChildren } from 'preact';
+export interface ListItemProps {
+    children?: ComponentChildren;
+    className?: string;
+    noMarkers?: boolean;
+}
+export interface ListProps {
+    children?: ComponentChildren;
+    className?: string;
+    nested?: boolean;
+    ordered?: boolean;
+    noMarkers?: boolean;
+}

package/dist/types/components/internal/Loader/Loader.d.ts

@@ -0,0 +1,22 @@
+import './_loader.scss';
+export type LoaderSize = 'xsmall' | 'small' | 'medium' | 'large';
+export interface LoaderProps {
+    /**
+     * Whether the spinner should be rendered inline
+     */
+    inline?: boolean;
+    /**
+     * size of the spinner (small/medium/large)
+     */
+    size?: LoaderSize;
+    /**
+     * includes a dot inside the spinner
+     */
+    dot?: boolean;
+}
+/**
+ * Default Loading Spinner
+ * @param props -
+ */
+declare const Loader: ({ inline, size, dot }: LoaderProps) => import("preact").JSX.Element;
+export default Loader;

package/dist/types/components/internal/Loader/index.d.ts

@@ -0,0 +1,2 @@
+export type { LoaderSize } from './Loader';
+export { default } from './Loader';

package/dist/types/components/internal/LoaderWrapper/LoaderWrapper.d.ts

@@ -0,0 +1,13 @@
+import { ComponentChildren } from 'preact';
+import { LoaderSize } from '../Loader';
+import { LoadingStatus } from './constants';
+interface LoaderWrapperProps {
+    status?: LoadingStatus;
+    formOpacityWhenLoading?: 0 | 0.1 | 0.2 | 0.3 | 0.4 | 0.5 | 0.6 | 0.7 | 0.8 | 0.9 | 1;
+    loaderSize?: LoaderSize;
+    children?: ComponentChildren;
+    showSpinner?: boolean;
+    className?: string;
+}
+declare const LoaderWrapper: ({ children, status, formOpacityWhenLoading, loaderSize, showSpinner, className, }: LoaderWrapperProps) => import("preact").JSX.Element;
+export default LoaderWrapper;

package/dist/types/components/internal/LoaderWrapper/constants.d.ts

@@ -0,0 +1 @@
+export type LoadingStatus = 'success' | 'loading';

package/dist/types/components/internal/LoaderWrapper/index.d.ts

@@ -0,0 +1 @@
+export { default } from './LoaderWrapper';

package/dist/types/components/internal/Menu/ActionsMenu.d.ts

@@ -0,0 +1,14 @@
+import './ActionsMenu.scss';
+export interface ActionsMenuOption {
+    label: string;
+    onSelect: () => void;
+    icon: string;
+    title?: string;
+}
+interface ActionsMenuProps {
+    options: ActionsMenuOption[];
+    open: boolean;
+    setOpen: (open: boolean) => void;
+}
+export declare const ActionsMenu: ({ options, open, setOpen }: ActionsMenuProps) => import("preact").JSX.Element;
+export {};

package/dist/types/components/internal/Name/Name.d.ts

@@ -0,0 +1,4 @@
+import { NameProps, NameSchema } from './types';
+export declare const nameFields: Array<keyof NameSchema>;
+declare const Name: import("preact").FunctionComponent<NameProps>;
+export default Name;

package/dist/types/components/internal/Name/index.d.ts

@@ -0,0 +1 @@
+export { default, nameFields } from './Name';