@progressiveui/react 1.22.0

package/es/dist/components/Accordion/components/Accordion.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { AccordionProviderOptions } from "../utils/constants";
+import { ControlledAccordionProps } from "./ControlledAccordion";
+interface AccordionProps extends AccordionProviderOptions, Omit<ControlledAccordionProps, "providerValue"> {
+}
+declare const Accordion: React.ForwardRefExoticComponent<AccordionProps & React.RefAttributes<HTMLDivElement>>;
+export { Accordion, AccordionProps };

package/es/dist/components/Accordion/components/AccordionItem.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+import { TransitionState } from "react-transition-state";
+import { ElementProps, ItemState, ItemStateOptions } from "../utils/constants";
+interface ItemElementProps<E extends HTMLElement> extends ElementProps<E, TransitionState> {
+    ref?: React.ForwardedRef<E>;
+}
+type NodeOrFunc = React.ReactNode | ((props: ItemState) => React.ReactNode);
+interface AccordionItemProps extends ItemStateOptions, ElementProps<HTMLDivElement, TransitionState> {
+    /**
+     * Either a React node or a function that returns a React node.
+     * This property defines the content of the accordion item's header.
+     */
+    header?: NodeOrFunc;
+    /**
+     * Can be either a React node or a function that returns a React node.
+     * This property defines the main content of the accordion item.
+     */
+    children?: NodeOrFunc;
+    /**
+     * Specifies the HTML tag to be used for the heading element of the accordion item.
+     * It can be any of the heading tags from 'h1' to 'h6'.
+     */
+    headingTag?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+    /**
+     * Properties to be passed to the heading element of the accordion item.
+     * It extends from `ItemElementProps` which includes standard HTML attributes and a ref.
+     */
+    headingProps?: ItemElementProps<HTMLHeadingElement>;
+    /**
+     * Properties to be passed to the button element within the accordion item.
+     * It extends from `ItemElementProps` which includes standard HTML attributes and a ref.
+     */
+    buttonProps?: ItemElementProps<HTMLButtonElement>;
+    /**
+     * Properties to be passed to the content container element of the accordion item.
+     * It extends from `ItemElementProps` which includes standard HTML attributes and a ref.
+     */
+    contentProps?: ItemElementProps<HTMLDivElement>;
+    /**
+     * Properties to be passed to the panel element inside the content container of the accordion item.
+     * It extends from `ItemElementProps` which includes standard HTML attributes and a ref.
+     */
+    panelProps?: ItemElementProps<HTMLDivElement>;
+}
+declare const AccordionItem: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
+export { AccordionItem, AccordionItemProps };

package/es/dist/components/Accordion/components/AccordionProvider.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { AccordionProviderValue } from "../utils/constants";
+declare const AccordionProvider: (props: {
+    value: AccordionProviderValue;
+    children?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export { AccordionProvider };

package/es/dist/components/Accordion/components/ControlledAccordion.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import { AccordionProviderValue, ElementProps } from "../utils/constants";
+interface ControlledAccordionProps extends ElementProps<HTMLDivElement> {
+    providerValue: AccordionProviderValue;
+    children?: React.ReactNode;
+}
+declare const ControlledAccordion: React.ForwardRefExoticComponent<ControlledAccordionProps & React.RefAttributes<HTMLDivElement>>;
+export { ControlledAccordion, ControlledAccordionProps };

package/es/dist/components/Accordion/components/withAccordionItem.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { ItemState, ItemStateOptions } from "../utils/constants";
+interface ItemStateProps<E extends Element, T = E> extends ItemState {
+    itemRef: React.RefObject<E>;
+    forwardedRef: React.ForwardedRef<T>;
+}
+declare const withAccordionItem: {
+    <P extends ItemStateOptions, E extends Element, T = E>(WrappedItem: any): React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
+    displayName: string;
+};
+export { withAccordionItem, ItemStateProps };

package/es/dist/components/Accordion/hooks/useAccordion.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from 'react';
+declare const useAccordion: () => {
+    accordionProps: HTMLAttributes<Element>;
+};
+export { useAccordion };

package/es/dist/components/Accordion/hooks/useAccordionContext.d.ts

@@ -0,0 +1,5 @@
+import { TransitionState } from 'react-transition-state';
+import { AccordionProviderValue, ItemKey } from '../utils/constants';
+declare const getItemState: (providerValue: AccordionProviderValue, key: ItemKey, itemInitialEntered?: boolean) => TransitionState;
+declare const useAccordionContext: () => AccordionProviderValue;
+export { useAccordionContext, getItemState };

package/es/dist/components/Accordion/hooks/useAccordionItem.d.ts

@@ -0,0 +1,7 @@
+import { HTMLAttributes, ButtonHTMLAttributes } from "react";
+import { ItemState } from "../utils/constants";
+declare const useAccordionItem: ({ state, toggle, disabled }: ItemState) => {
+    buttonProps: ButtonHTMLAttributes<Element>;
+    panelProps: HTMLAttributes<Element>;
+};
+export { useAccordionItem };

package/es/dist/components/Accordion/hooks/useAccordionItemEffect.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { ItemStateOptions } from '../utils/constants';
+declare const useAccordionItemEffect: <E extends Element>({ itemKey, initialEntered, disabled, }?: ItemStateOptions) => {
+    itemRef: import("react").RefObject<HTMLInputElement>;
+    state: Readonly<{
+        status: import("react-transition-state").TransitionStatus;
+        isMounted: boolean;
+        isEnter: boolean;
+        isResolved: boolean;
+    }>;
+    toggle: (toEnter?: boolean) => void;
+};
+export { useAccordionItemEffect };

package/es/dist/components/Accordion/hooks/useAccordionProvider.d.ts

@@ -0,0 +1,3 @@
+import { AccordionProviderOptions, AccordionProviderValue } from '../utils/constants';
+declare const useAccordionProvider: (options?: AccordionProviderOptions) => AccordionProviderValue;
+export { useAccordionProvider };

package/es/dist/components/Accordion/hooks/useAccordionState.d.ts

@@ -0,0 +1,14 @@
+import { ItemKey } from '../utils/constants';
+declare const useAccordionState: () => {
+    getItemState: (key: ItemKey, { initialEntered }?: {
+        initialEntered?: boolean | undefined;
+    }) => Readonly<{
+        status: import("react-transition-state").TransitionStatus;
+        isMounted: boolean;
+        isEnter: boolean;
+        isResolved: boolean;
+    }>;
+    toggle: (key: ItemKey, toEnter?: boolean | undefined) => void;
+    toggleAll: (toEnter?: boolean | undefined) => void;
+};
+export { useAccordionState };

package/es/dist/components/Accordion/hooks/useHeightTransition.d.ts

@@ -0,0 +1,4 @@
+import { CSSProperties } from 'react';
+import { TransitionState } from 'react-transition-state';
+declare const useHeightTransition: <E extends Element>({ status, isResolved, }: TransitionState) => readonly [CSSProperties, import("react").RefObject<HTMLInputElement>];
+export { useHeightTransition };

package/es/dist/components/Accordion/hooks/useId.d.ts

@@ -0,0 +1,3 @@
+import { useId } from 'react';
+declare const _useId: typeof useId;
+export { _useId as useId };

package/es/dist/components/Accordion/hooks/useMergeRef.d.ts

@@ -0,0 +1,4 @@
+import { RefCallback, MutableRefObject } from 'react';
+type Ref<T> = RefCallback<T> | MutableRefObject<T | null>;
+declare function useMergeRef<T>(refA?: Ref<T> | null, refB?: Ref<T> | null): Ref<T> | null | undefined;
+export { useMergeRef };

package/es/dist/components/Accordion/index.d.ts

@@ -0,0 +1,17 @@
+export { Accordion } from "./components/Accordion";
+export { AccordionItem } from "./components/AccordionItem";
+export { AccordionProvider } from "./components/AccordionProvider";
+export { ControlledAccordion } from "./components/ControlledAccordion";
+export { withAccordionItem } from "./components/withAccordionItem";
+export { useAccordion } from "./hooks/useAccordion";
+export { useAccordionItem } from "./hooks/useAccordionItem";
+export { useAccordionItemEffect } from "./hooks/useAccordionItemEffect";
+export { useAccordionProvider } from "./hooks/useAccordionProvider";
+export { useAccordionState } from "./hooks/useAccordionState";
+export { useHeightTransition } from "../../hooks/useHeightTransition";
+export { useMergeRef } from "../../hooks/useMergeRef";
+export type { AccordionProps } from "./components/Accordion";
+export type { AccordionItemProps } from "./components/AccordionItem";
+export type { ControlledAccordionProps } from "./components/ControlledAccordion";
+export type { ItemStateProps } from "./components/withAccordionItem";
+export type { AccordionProviderOptions, AccordionProviderValue, ItemState, ItemStateOptions, TransitionProp, } from "./utils/constants";

package/es/dist/components/Accordion/utils/bem.d.ts

@@ -0,0 +1,7 @@
+import { ClassNameProp, Modifiers } from './constants';
+/**
+ * Generate className following BEM methodology: http://getbem.com/naming/
+ * Modifier value can be one of the types: boolean, string
+ */
+declare const bem: (block: string, element?: string, modifiers?: Modifiers) => <P>(className?: ClassNameProp<P> | undefined, props?: P | undefined) => string;
+export { bem };

package/es/dist/components/Accordion/utils/constants.d.ts

@@ -0,0 +1,58 @@
+import { HTMLAttributes } from "react";
+import { TransitionState, TransitionMapResult, TransitionMapOptions, TransitionOptions } from "react-transition-state";
+export declare const ACCORDION_BLOCK = "szh-accordion";
+export declare const ACCORDION_PREFIX = "szh-adn";
+export declare const ACCORDION_ATTR: string;
+export declare const ACCORDION_BTN_ATTR: string;
+export type Modifiers = {
+    readonly [index: string]: boolean | string;
+};
+export type ClassNameProp<P> = string | ((props: P) => string);
+export interface ElementProps<E extends HTMLElement, P = undefined> extends Omit<HTMLAttributes<E>, "className" | "children"> {
+    className?: P extends undefined ? string : ClassNameProp<P>;
+    "data-testid"?: string | number;
+}
+export type ItemKey = Element | string | number;
+export type TransitionProp = boolean | {
+    enter?: boolean;
+    exit?: boolean;
+    preEnter?: boolean;
+    preExit?: boolean;
+};
+export interface ItemState {
+    readonly state: TransitionState;
+    readonly toggle: (toEnter?: boolean) => void;
+    disabled?: boolean;
+}
+export interface ItemStateOptions {
+    itemKey?: string | number;
+    initialEntered?: boolean;
+    disabled?: boolean;
+}
+export interface AccordionProviderOptions extends Omit<TransitionMapOptions<ItemKey>, "enter" | "exit" | "preEnter" | "preExit" | "timeout"> {
+    /**
+     * The transition behavior for the accordion.
+     * It can take a TransitionProp type which specifies the type of transition.
+     */
+    transition?: TransitionProp;
+    /**
+     *  Set the timeout duration for transitions.
+     * It uses the 'timeout' type from TransitionOptions to specify the duration in milliseconds.
+     */
+    transitionTimeout?: TransitionOptions["timeout"];
+}
+export interface AccordionProviderValue extends TransitionMapResult<ItemKey> {
+    /**
+     * Determines whether the accordion item should be mounted
+     * in the DOM only when it enters. A true value means the item will only mount when
+     * it is opened (entered state).
+     */
+    mountOnEnter: boolean;
+    /**
+     * Indicates whether the accordion item should be in the
+     * entered (or opened) state initially. This can be used to display the accordion item
+     * as open by default when the component is first rendered.
+     */
+    initialEntered: boolean;
+}
+export declare const AccordionContext: import("react").Context<Partial<AccordionProviderValue>>;

package/es/dist/components/Accordion/utils/mergeProps.d.ts

@@ -0,0 +1,2 @@
+declare const mergeProps: (target: any, source: any) => any;
+export { mergeProps };

package/es/dist/components/Accordion/utils/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+export { useIsomorphicLayoutEffect as useLayoutEffect };

package/es/dist/components/AnchorNavigation/AnchorNavigation.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+interface AnchorNavigationProps extends React.ComponentPropsWithRef<"div"> {
+    title?: string;
+}
+declare const AnchorNavigation: React.FC<AnchorNavigationProps>;
+export default AnchorNavigation;

package/es/dist/components/AnchorNavigation/index.d.ts

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

package/es/dist/components/AuthLayout/AuthLayout.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import type { PropsWithChildren } from 'react';
+type AuthLayoutProps = PropsWithChildren<{
+    /**
+     * The CSS class name to be placed on the wrapping element.
+     */
+    className?: string;
+    /**
+     * The image is set as background on the left section when provided
+     */
+    image?: React.ReactNode;
+    /**
+     * This usually consist of `<BackgroundContent/>` if you wish to provide content and background color instead of an image
+     */
+    backgroundContent?: React.ReactNode;
+}>;
+declare const AuthLayout: React.FC<AuthLayoutProps>;
+type BackgroundContentProps = React.ComponentPropsWithRef<'div'>;
+declare const BackgroundContent: React.FC<BackgroundContentProps>;
+export { BackgroundContent, AuthLayout };

package/es/dist/components/AuthLayout/index.d.ts

@@ -0,0 +1 @@
+export { AuthLayout, BackgroundContent } from './AuthLayout';

package/es/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { User as UserIcon } from "@progressiveui/icons-react";
+export interface AvatarProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Provide the alt text for the image.
+     */
+    alt?: string;
+    /**
+     * Specify the type of Tag @design
+     */
+    missingImage?: "avatar" | "letter";
+    /**
+     * Url to an avatar image The size of the image is 25px * 25px.
+     * Provide at least 50px * 50px to support HiDPI displays.
+     */
+    image?: string;
+    /**
+     * The username which will be displayed in the avatar.
+     */
+    name?: string;
+    /**
+     * Additional props for the UserIcon component
+     */
+    userIconProps?: React.ComponentProps<typeof UserIcon>;
+}
+/**
+ * Avatar is used to display a user image or icon.
+ */
+declare function Avatar({ alt, className, image, missingImage, name, userIconProps, ...other }: AvatarProps): import("react/jsx-runtime").JSX.Element | null;
+declare namespace Avatar {
+    var displayName: string;
+}
+export default Avatar;

package/es/dist/components/Avatar/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Avatar";

package/es/dist/components/BannerNavigation/BannerNavigation.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+export interface BannerNavigationItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The CSS class name to be placed on the wrapping element.
+     */
+    className?: string;
+}
+declare const BannerNavigationItem: React.FC<BannerNavigationItemProps>;
+export interface BannerNavigationProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The CSS class name to be placed on the wrapping element.
+     */
+    className?: string;
+    /**
+     * Specify the max-width on desktop devices (same as \`Wrapper\` component)
+     */
+    pageWidth?: "sm" | "md" | "lg" | "full";
+}
+declare const BannerNavigation: React.FC<BannerNavigationProps>;
+export { BannerNavigation, BannerNavigationItem };

package/es/dist/components/BannerNavigation/BannerNavigationWithContent.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+type BannerNavigationWithContentProps = {
+    /**
+     * A onChange Function for the search
+     */
+    searchOnChange?: () => {};
+    /**
+     * Allows to disable the search input
+     */
+    search?: boolean;
+};
+declare const BannerNavigationWithContent: React.FC<BannerNavigationWithContentProps>;
+export { BannerNavigationWithContent };

package/es/dist/components/BannerNavigation/index.d.ts

@@ -0,0 +1,2 @@
+export { BannerNavigation, BannerNavigationItem } from './BannerNavigation';
+export { BannerNavigationWithContent } from './BannerNavigationWithContent';

package/es/dist/components/Breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+/**
+ * The breadcrumb is a secondary navigation pattern that helps a user understand the hierarchy among levels and navigate back through them. */
+interface BreadcrumbProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Pass in the BreadcrumbItem's for your Breadcrumb
+     */
+    children?: React.ReactNode;
+}
+declare const Breadcrumb: ({ children, className, ...other }: BreadcrumbProps) => import("react/jsx-runtime").JSX.Element;
+export default Breadcrumb;

package/es/dist/components/Breadcrumb/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Breadcrumb";

package/es/dist/components/BreadcrumbHome/BreadcrumbHome.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+interface BreadcrumbHomeProps {
+    /**
+     * Specify an optional text for the `Home` Icon
+     */
+    hometext?: React.ReactNode;
+    /**
+     * Specify an optional className to be added to the `Home` Icon
+     */
+    className?: string;
+}
+declare const BreadcrumbHome: React.FC<BreadcrumbHomeProps>;
+export default BreadcrumbHome;

package/es/dist/components/BreadcrumbHome/index.d.ts

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

package/es/dist/components/BreadcrumbItem/BreadcrumbItem.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+interface BreadcrumbItemProps extends React.ComponentPropsWithoutRef<"div"> {
+    /**
+     * Specify an link for the `BreadcrumbItem`
+     */
+    href?: string;
+    /**
+     * The children elements, usually a link
+     */
+    children?: React.ReactNode;
+    /**
+     * Specify `BreadcrumbItem` to be interactive/enabled or non-interactive/disabled
+     */
+    disableLink?: boolean;
+    /**
+     * Specify an optional className to be added to the `BreadcrumbItem` Icon
+     */
+    className?: string;
+}
+declare const BreadcrumbItem: ({ children, className, disableLink, href, ...other }: BreadcrumbItemProps) => import("react/jsx-runtime").JSX.Element;
+export default BreadcrumbItem;

package/es/dist/components/BreadcrumbItem/index.d.ts

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

package/es/dist/components/Button/Button.Skeleton.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+interface ButtonSkeletonProps {
+    small?: boolean;
+    href?: string;
+}
+declare const ButtonSkeleton: React.FC<ButtonSkeletonProps>;
+export default ButtonSkeleton;

package/es/dist/components/Button/Button.d.ts

@@ -0,0 +1,55 @@
+import * as React from "react";
+import { ButtonKind } from "../../utils";
+interface ButtonBaseProps {
+    /**
+     * Content of the Button @design
+     */
+    children?: React.ReactNode;
+    /**
+     * Specify whether the Button should be a small variant @design
+     */
+    small?: boolean;
+    /**
+     * Specify whether the Button should be a large variant
+     */
+    large?: boolean;
+    /**
+     * Specify btnSolid to buttons on solid background to make it stand out
+     */
+    btnSolid?: boolean;
+    /**
+     * Specify the kind of Button you want to create @design
+     */
+    kind?: ButtonKind;
+    /**
+     * Optionally specify an href for your Button to become an element
+     */
+    href?: string;
+    /**
+     * Specify an `icon` to include in the Button through an object representing the SVG data of the icon, similar to the `Icon` component @design
+     */
+    icon?: React.ReactNode | React.ComponentType<any>;
+    /**
+     * Optionally specify an href for your Button to become an element @design
+     */
+    iconReverse?: boolean;
+    iconDescription?: string;
+    /**
+     * Specify whether the Button should be disabled, or not
+     */
+    disabled?: boolean;
+    /**
+     * Optional prop to specify the tabIndex of the Button
+     */
+    tabIndex?: number;
+    target?: React.AnchorHTMLAttributes<HTMLAnchorElement>["target"];
+    useFlexbox?: boolean;
+    id?: string;
+}
+interface ButtonButtonProps extends ButtonBaseProps, React.ComponentPropsWithoutRef<"button"> {
+}
+/**
+ * Buttons express what action will occur when the user clicks or touches it. Buttons are used to initialize an action, either in the background or foreground of an experience. */
+export type ButtonRef<T extends React.ElementType> = React.ComponentPropsWithRef<T>["ref"];
+export declare const Button: React.ForwardRefExoticComponent<ButtonButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export default Button;

package/es/dist/components/Button/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Button";

package/es/dist/components/Card/Card.d.ts

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import type { PropsWithChildren } from 'react';
+import { CardKind } from '../../utils';
+/**
+ * Cards are a convenient means of displaying content composed of different types of objects. It is a multi usage component which creates boxes that are usually teasing some kind of content. */
+type CardProps = PropsWithChildren<{
+    /**
+     Additional className which will be added
+   */
+    className?: string;
+    /**
+     An optimized photograph
+   */
+    image?: string;
+    /**
+    isExternal if true, opens link in a different window
+  */
+    isExternal?: boolean;
+    /**
+    Render the Card as link
+  */
+    isLink?: boolean;
+    /**
+    A short sentence to explain the content of the node (max 180 characters)
+  */
+    subTitle?: React.ReactNode;
+    /**
+     A search-friendly title (ideally 50 characters, max 100)
+  */
+    title?: string | React.ReactNode;
+    /**
+    Additional metadatas
+  */
+    metadata?: string;
+    /**
+     * Alternative text for image
+     */
+    alt?: string;
+    /**
+     * The content of the Card
+     */
+    children?: React.ReactNode;
+    /**
+    Kind of Card
+  */
+    kind?: CardKind;
+    /**
+    The URL where the content uploaded is located.
+  */
+    url?: string;
+    /**
+     * override default card width with preferred width
+     */
+    cardWidth?: string;
+    /**
+     * override default card width with preferred width
+     */
+    cardHeight?: string;
+}>;
+declare const Card: React.FC<CardProps>;
+export default Card;

package/es/dist/components/Card/CardExternal.d.ts

@@ -0,0 +1,37 @@
+import React from "react";
+import PropTypes from "prop-types";
+interface CardExternalProps {
+    label?: string;
+    labelStatus?: boolean;
+    interactive?: boolean;
+    image?: string;
+    heading?: string;
+    subHeading?: string;
+    caption?: string;
+    tag?: string;
+    children?: React.ReactNode;
+    className?: string;
+    truncated?: boolean;
+}
+declare const CardExternal: {
+    ({ label, labelStatus, interactive, image, heading, subHeading, caption, tag, children, className, ...other }: CardExternalProps): import("react/jsx-runtime").JSX.Element;
+    propTypes: {
+        /**
+         label description for card if any
+        */
+        label: PropTypes.Requireable<string>;
+        /**
+         labelStatus is either true or false, it applies  for card if any
+        */
+        labelStatus: PropTypes.Requireable<boolean>;
+        image: PropTypes.Requireable<string>;
+        heading: PropTypes.Requireable<string>;
+        subHeading: PropTypes.Requireable<string>;
+        caption: PropTypes.Requireable<string>;
+        tag: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        interactive: PropTypes.Requireable<boolean>;
+        className: PropTypes.Requireable<string>;
+    };
+};
+export default CardExternal;

package/es/dist/components/Card/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Card } from './Card';
+export { default as CardExternal } from './CardExternal';

package/es/dist/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,37 @@
+import * as React from "react";
+interface CheckboxProps extends Omit<React.ComponentPropsWithRef<"input">, "onChange"> {
+    /**
+     * Specify whether the Checkbox is in an indeterminate state
+     */
+    indeterminate?: boolean;
+    /**
+     * Provide a label to provide a description of the Checkbox input that you are
+     * exposing to the user
+     */
+    labelText?: React.ReactNode;
+    /**
+     * Specify whether the label should be hidden, or not
+     */
+    hideLabel?: boolean;
+    /**
+     * Invalid state for the checkbox
+     */
+    invalid?: boolean;
+    /**
+     * Provide the text that is displayed when the checkbox is in an invalid state
+     */
+    invalidText?: string;
+    /**
+     * The CSS class name to be placed on the wrapping element
+     */
+    wrapperClassName?: string;
+    /**
+     *
+     * @param event | The event triggering the change
+     * @param checked | The new value of the checkbox
+     * @param customId | The id of the checkbox
+     */
+    onChange?(event: React.ChangeEvent<HTMLInputElement>, checked?: boolean, customId?: string): void;
+}
+export declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export default Checkbox;

package/es/dist/components/Checkbox/index.d.ts

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