@progressiveui/react 2.0.3 → 2.0.4

package/dist/components/Accordion/__tests__/utils.d.ts

@@ -0,0 +1,12 @@
+import { Ref, ReactElement } from 'react';
+import { render as nonStrictRender, RenderOptions, RenderResult } from '@testing-library/react';
+import { AccordionProps, AccordionItemProps } from '..';
+export { nonStrictRender };
+export declare const render: (ui: ReactElement, options?: Omit<RenderOptions, "queries">) => RenderResult;
+export declare const getAccordion: ({ ref, item1Ref, props, item1Props, item2Props, }?: {
+    ref?: Ref<HTMLDivElement>;
+    item1Ref?: Ref<HTMLDivElement>;
+    props?: AccordionProps;
+    item1Props?: AccordionItemProps;
+    item2Props?: AccordionItemProps;
+}) => import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -0,0 +1,46 @@
+import { TransitionState } from 'react-transition-state';
+import { ElementProps, ItemState, ItemStateOptions } from '../utils/constants';
+import * as React from "react";
+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/dist/components/Accordion/components/AccordionProvider.d.ts

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

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

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

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

@@ -0,0 +1,11 @@
+import { ItemState, ItemStateOptions } from '../utils/constants';
+import * as React from "react";
+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/dist/components/Accordion/hooks/useAccordion.d.ts

@@ -0,0 +1,8 @@
+import { HTMLAttributes } from 'react';
+interface AccordionHTMLAttributes<T> extends HTMLAttributes<T> {
+    "data-accordion"?: string;
+}
+declare const useAccordion: () => {
+    accordionProps: AccordionHTMLAttributes<Element>;
+};
+export { useAccordion };

package/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/dist/components/Accordion/hooks/useAccordionItemEffect.d.ts

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

package/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;
+    }) => Readonly<{
+        status: import('react-transition-state').TransitionStatus;
+        isMounted: boolean;
+        isEnter: boolean;
+        isResolved: boolean;
+    }>;
+    toggle: (key: ItemKey, toEnter?: boolean) => void;
+    toggleAll: (toEnter?: boolean) => void;
+};
+export { useAccordionState };

package/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/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>, props?: P) => string;
+export { bem };

package/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 = "data-szh-adn";
+export declare const ACCORDION_BTN_ATTR = "data-szh-adn-btn";
+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/dist/components/AnchorNavigation/AnchorNavigation-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/AuthLayout/AuthLayout-test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,20 @@
+import { PropsWithChildren } from 'react';
+import * as React 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/dist/components/Avatar/Avatar.d.ts

@@ -0,0 +1,33 @@
+import { User as UserIcon } from '@progressiveui/icons-react';
+import * as React from "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/dist/components/Avatar/index.d.ts

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

package/dist/components/BannerNavigation/BannerNavigation-test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export default iconNames;
+declare const iconNames: string[];

package/dist/components/Breadcrumb/Breadcrumb-test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export default BreadcrumbSkeleton;
+declare function BreadcrumbSkeleton(): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+import { default as 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/dist/components/Breadcrumb/index.d.ts

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

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

@@ -0,0 +1,21 @@
+import { default as 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/dist/components/Button/Button.d.ts

@@ -0,0 +1,59 @@
+import { ButtonKind } from '../../utils';
+import * as React from "react";
+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;
+    /**
+     * Icon description for accessibility
+     */
+    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/dist/components/Button/index.d.ts

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

package/dist/components/Card/Card-old.d.ts

@@ -0,0 +1,25 @@
+import { default as PropTypes } from 'prop-types';
+export default Card;
+/**
+ * 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. */
+declare function Card(props: any): import("react/jsx-runtime").JSX.Element;
+declare namespace Card {
+    namespace propTypes {
+        let className: PropTypes.Requireable<string>;
+        let image: PropTypes.Requireable<string>;
+        let components: PropTypes.Requireable<object>;
+        let isExternal: PropTypes.Requireable<boolean>;
+        let isLink: PropTypes.Requireable<boolean>;
+        let subTitle: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let title: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        let metadata: PropTypes.Requireable<string>;
+        let kind: PropTypes.Validator<string>;
+        let url: PropTypes.Requireable<string>;
+        let cardWidth: PropTypes.Requireable<string>;
+        let cardHeight: PropTypes.Requireable<string>;
+    }
+    namespace defaultProps {
+        let isLink_1: boolean;
+        export { isLink_1 as isLink };
+    }
+}

package/dist/components/Card/Card-test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,61 @@
+import { PropsWithChildren } from 'react';
+import { CardKind } from '../../utils';
+import * as React from 'react';
+/**
+ * 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/dist/components/Card/CardExternal.d.ts

@@ -0,0 +1,37 @@
+import { default as React } from 'react';
+import { default as 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/dist/components/Checkbox/Checkbox-old.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+export default Checkbox;
+declare const Checkbox: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

package/dist/components/Checkbox/Checkbox-test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,11 @@
+import { default as PropTypes } from 'prop-types';
+export default CheckboxSkeleton;
+declare function CheckboxSkeleton({ className, ...rest }: {
+    [x: string]: any;
+    className: any;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace CheckboxSkeleton {
+    namespace propTypes {
+        let className: PropTypes.Requireable<string>;
+    }
+}

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

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export default Checkbox;
+/**
+ * Checkboxes are used for a list of options where the user may select multiple options, including all or none. */
+declare const Checkbox: React.ForwardRefExoticComponent<React.RefAttributes<any>>;

package/dist/components/CheckboxGroup/RadioButtonGroup.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (props?: object) => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/dist/components/CheckboxGroup/RadioButtonGroupWithoutControls.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (props?: object) => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/dist/components/CheckboxGroup/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/ContentSwitcher/ContentSwitcher-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/ContentSwitcher/ContentSwitcher.d.ts

@@ -0,0 +1,11 @@
+import { default as React, PropsWithChildren } from 'react';
+/** ContentSwitcher manipulates the content shown following an exclusive or “either/or” pattern. It is used to toggle between two or more content sections within the same space on screen. Only one section can be shown at a time.
+ */
+type ContentSwitcherProps = PropsWithChildren<{
+    className?: string;
+    selectedIndex?: number;
+    small?: boolean;
+    onChange: (data?: object) => void;
+}>;
+declare const ContentSwitcher: React.FC<ContentSwitcherProps>;
+export default ContentSwitcher;

package/dist/components/ContextMenu/ContextMenu.d.ts

@@ -0,0 +1,31 @@
+import { PropsWithChildren } from 'react';
+import * as React from 'react';
+/** Context menu are used as navigational elements. They should contain commands that apply to the target object. */
+type ContextMenuProps = PropsWithChildren<{
+    /**
+     * Provide content to display when contextMenu is clicked
+     */
+    content?: React.ReactNode;
+    /**
+     * Provide a href prop as an alternative to onClick
+     */
+    href?: string;
+    /**
+     * Inline links are used within a sentence or paragraph and are styled with an underline. They should not be paired with an icon.
+     */
+    inline?: boolean;
+    /**
+     * Provide a custom className
+     */
+    className?: string;
+}>;
+declare const ContextMenu: React.FC<ContextMenuProps>;
+type ContextMenuGroupProps = PropsWithChildren<{
+    className?: string;
+}>;
+declare const ContextMenuGroup: React.FC<ContextMenuGroupProps>;
+interface ContextMenuItemProps extends React.ComponentPropsWithRef<'div'> {
+    className?: string;
+}
+declare const ContextMenuItem: React.FC<ContextMenuItemProps>;
+export { ContextMenu, ContextMenuItem, ContextMenuGroup };

package/dist/components/Credits/Credits-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,8 @@
+import { InputProps } from '../Input';
+import { DatePickerInputProps } from './DatePickerInput';
+import * as React from "react";
+/** DatePicker with the Input wrapper */
+interface DatePickerProps extends InputProps, DatePickerInputProps {
+}
+declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLInputElement>>;
+export default DatePicker;