@luscii-healthtech/web-ui 0.0.0-alpha.2fcd0e9

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

@@ -0,0 +1,49 @@
+export { default as AddIcon } from "./AddIcon";
+export { default as AlertsIcon } from "./AlertsIcon";
+export { default as BellIcon } from "./BellIcon";
+export { default as BluetoothIcon } from "./BluetoothIcon";
+export { default as ChartIcon } from "./ChartIcon";
+export { default as ChartLineColoredIcon } from "./ChartLineColoredIcon";
+export { default as ChatBoxIcon } from "./ChatBoxIcon";
+export { default as CheckIcon } from "./CheckIcon";
+export { default as ChevronDoubleIcon } from "./ChevronDoubleIcon";
+export { default as ChevronDownIcon } from "./ChevronDownIcon";
+export { default as ChevronRightIcon } from "./ChevronRightIcon";
+export { default as CrossIcon } from "./CrossIcon";
+export { default as DeleteIcon } from "./DeleteIcon";
+export { default as DownArrowIcon } from "./DownArrowIcon";
+export { default as DragIcon } from "./DragIcon";
+export { default as EditIcon } from "./EditIcon";
+export { default as EmptyIcon } from "./EmptyIcon";
+export { default as EmptyStateDashboardIcon } from "./EmptyStateDashboardIcon";
+export { default as ExclamationMarkIcon } from "./ExclamationMarkIcon";
+export { default as EyeIconSlashed } from "./EyeIconSlashed";
+export { default as EyeIcon } from "./EyeIcon";
+export { default as GearColoredIcon } from "./GearColoredIcon";
+export { default as GearIcon } from "./GearIcon";
+export { default as GroupColoredIcon } from "./GroupColoredIcon";
+export { default as GroupIcon } from "./GroupIcon";
+export { default as HamburgerIcon } from "./HamburgerIcon";
+export { default as HeartIcon } from "./HeartIcon";
+export { default as ImageIcon } from "./ImageIcon";
+export { default as InfoIcon } from "./InfoIcon";
+export { default as LeftArrowIcon } from "./LeftArrowIcon";
+export { default as LightBulbIcon } from "./LightBulbIcon";
+export { default as LinkIcon } from "./LinkIcon";
+export { default as LockIcon } from "./LockIcon";
+export { default as MessagesIcon } from "./MessagesIcon";
+export { default as MouseIcon } from "./MouseIcon";
+export { default as NotesIcon } from "./NotesIcon";
+export { default as PageViewIcon } from "./PageViewIcon";
+export { default as PinIcon } from "./PinIcon";
+export { default as PrintIcon } from "./PrintIcon";
+export { default as RightArrowIcon } from "./RightArrowIcon";
+export { default as SearchCancelIcon } from "./SearchCancelIcon";
+export { default as SearchIcon } from "./SearchIcon";
+export { default as SmallCircleIcon } from "./SmallCircleIcon";
+export { default as SmallDiamondIcon } from "./SmallDiamondIcon";
+export { default as SmallSquareIcon } from "./SmallSquareIcon";
+export { default as SpaceRocketIcon } from "./SpaceRocketIcon";
+export { default as StarIcon } from "./StarIcon";
+export { default as StatusColoredIcon } from "./StatusColoredIcon";
+export { default as WarningIcon } from "./WarningIcon";

package/dist/components/Icons/templates/component.d.ts

@@ -0,0 +1,3 @@
+declare const template: (variables: any, { tpl }: {
+    tpl: any;
+}) => any;

package/dist/components/Icons/templates/index.d.ts

@@ -0,0 +1,2 @@
+declare const path: any;
+declare function defaultIndexTemplate(filePaths: any): string;

package/dist/components/Icons/types/IconProps.type.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import * as Icons from "../index";
+export interface IconProps {
+    className?: string;
+    onClick?: (event: React.MouseEvent<SVGSVGElement> | undefined) => void;
+    "data-test-id"?: string;
+}
+export type IconKey = keyof typeof Icons;

package/dist/components/Image/Image.d.ts

@@ -0,0 +1,10 @@
+import React, { MouseEventHandler } from "react";
+interface ImageProps {
+    src: string;
+    className: string;
+    children?: React.ReactNode;
+    onClick?: MouseEventHandler<HTMLSpanElement>;
+    showIconOnFailure?: boolean;
+}
+declare const Image: React.VFC<ImageProps>;
+export default Image;

package/dist/components/InfoField/InfoField.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+interface InfoFieldProps {
+    label: string;
+    value: string;
+    /**
+     * Gives the component interactive abilities. The `value` prop
+     * is used in conjunction with this.
+     *
+     * @example
+     * ```tsx
+     * // The `value` prop will be used as the `href` attribute of the link. This will open a new tab.
+     * <InfoField linkType="link" value="https://www.nos.nl" />
+     *
+     * // The `value` prop will be copied to the clipboard when the user clicks the component.
+     * <InfoField linkType="clipboard" value="14/09/1988" />
+     *
+     * // A phone call will be triggered based on the phone number in the `value` prop.
+     * <InfoField linkType="tel" value="+31612345678" />
+     * ```
+     */
+    linkType: "none" | "link" | "clipboard" | "tel";
+    supportsMultiline?: boolean;
+    onCopyToClipboard?: (value?: string) => void;
+    icon?: JSX.Element;
+    className?: string;
+}
+export declare const InfoField: (props: InfoFieldProps) => JSX.Element;
+export {};

package/dist/components/Input/Input.d.ts

@@ -0,0 +1,57 @@
+import React from "react";
+import { AllowedTextInputTypes } from "../Form/form.types";
+import type { IconKey, IconProps } from "../Icons/types/IconProps.type";
+import { FormFieldWidth } from "../Form/form.types";
+import "./Input.css";
+export declare const INPUT_TYPES: Record<string, AllowedTextInputTypes>;
+/**
+ * It's very complicated to tap into the onChange events of inputs,
+ * so I omit the type it requires and add a easier one to deal with.
+ */
+type CustomHTMLInputProps = Omit<React.HTMLProps<HTMLInputElement>, "onChange" | "ref"> & {
+    isError?: boolean;
+};
+export type FakeEventTarget = {
+    target: {
+        value: string;
+        name: string;
+    };
+    currentTarget: {
+        value: string;
+        name: string;
+    };
+};
+export interface InputProps extends CustomHTMLInputProps {
+    type?: AllowedTextInputTypes;
+    clearable?: boolean;
+    isDisabled?: boolean;
+    withPrefix?: string;
+    withSuffix?: string;
+    icon?: React.FC<IconProps> | IconKey;
+    width?: FormFieldWidth;
+    /**
+     * Check the `asFormField` prop of this component to understand why this signature.
+     */
+    onChange?: (event: FakeEventTarget | string) => void;
+    /**
+     * ### TO BE USED WHEN INSIDE REACT-HOOK-FORM
+     *
+     * react-hook-form uses the onChange event differently.
+     * Instead of passing an `event` object, it uses the value itself from the callback.
+     *
+     * So we need to use this flag to determine how to call the onChange callback.
+     *
+     * @example
+     *
+     * // In react-hook-forms:
+     *
+     * onChange({target: { name: 'myInput' }, value: 'text'}) // -> this whole object will be set as the value
+     *
+     * // so instead do:
+     *
+     * onChange('text') // -> 🤝
+     */
+    asFormField?: boolean;
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export default Input;

package/dist/components/Input/SearchInput.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import Input from "./Input";
+type InputProps = React.ComponentProps<typeof Input>;
+export type SearchInputProps = Omit<InputProps, "icon" | "type" | "width" | "clearable" | "withSuffix" | "withPrefix" | "asFormField" | "isError"> & {
+    /**
+     * WARNING: Please note that this value is currently not passed on to the
+     * component. It's not deprecated, it will most likely be implemented correctly
+     * at a later stage.
+     */
+    width?: InputProps["width"];
+    /**
+     * @deprecated
+     * A search input should never be used in a form with multiple fields.
+     */
+    asFormField?: InputProps["asFormField"];
+    /**
+     * @deprecated
+     * A search input should never be in error state, because the
+     * user cannot do anything wrong when typing in this field.
+     */
+    isError?: InputProps["isError"];
+};
+export declare const SearchInput: React.ForwardRefExoticComponent<Omit<SearchInputProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1,19 @@
+import React from "react";
+/**
+ * Source for the typing of the `as` prop:  https://stackoverflow.com/a/66568474
+ */
+type Props<E extends React.ElementType> = React.PropsWithChildren<{
+    /**
+     * Provide a custom component tag name to render instead of the default `a` tag.
+     *
+     * @default "a"
+     * @example "button"
+     */
+    as?: E;
+}>;
+/**
+ * A bare-bones wrapper around an <a> tag, containing only our preferred styling. This is component
+ * can be used for any link and not just text links.
+ */
+export declare function Link<T extends React.ElementType = "a">(props: Props<T> & Omit<React.ComponentPropsWithoutRef<T>, keyof Props<T>>): React.JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+import React from "react";
+import type { ListItemProps, ListProps } from "./List.types";
+import "./List.scss";
+export { ListProps, ListItemProps };
+declare const List: React.FC<ListProps>;
+export default List;

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

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import type { BaseListProps, BaseListItemProps, OnAssetLoadErrorPayload, DraggableBaseListProps, SortableBaseListProps } from "../BaseList/BaseList.types";
+export type ListItemProps = Omit<BaseListItemProps, "onClick"> & {
+    handleItemClick?: (e: React.MouseEvent<HTMLLIElement>) => void;
+};
+export type DefaultListProps = Omit<BaseListProps<ListItemProps>, "renderItem" | "itemComponent"> & {
+    onDragEnd?: (itemId: string | number, newIndex: number) => void;
+    onAssetLoadError?: (payload: OnAssetLoadErrorPayload) => void;
+};
+export type DraggableListProps = DraggableBaseListProps;
+export type SortableListProps = SortableBaseListProps;
+export type SortableListItemProps = SortableListProps["items"][number];
+export type ListProps = ({
+    draggableListType: "default";
+} & DefaultListProps) | ({
+    draggableListType: "draggable";
+} & DraggableListProps) | ({
+    draggableListType: "sortable";
+} & SortableListProps) | DefaultListProps;

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

@@ -0,0 +1,4 @@
+import React from "react";
+import { ListItemProps } from "./List.types";
+export declare const ListItem: React.FC<ListItemProps>;
+export default ListItem;

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

@@ -0,0 +1,5 @@
+export { default as List } from "./List";
+export { ListItem } from "./ListItem";
+export type { ListProps, ListItemProps, DraggableListProps, SortableListProps, SortableListItemProps, } from "./List.types";
+export type { OnAssetLoadErrorPayload } from "../BaseList";
+export { getDndListItemProps } from "../BaseList";

package/dist/components/LoadingIndicator/LoadingIndicator.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { RestPropped } from "../../types/general.types";
+import "./LoadingIndicator.scss";
+export interface LoadingIndicatorProps extends RestPropped {
+    asModal?: boolean;
+    asSpinner?: boolean;
+    className?: string;
+    spinnerColor?: "blue" | "gray";
+    dataTestId?: string;
+}
+export declare function LoadingIndicator({ asModal, asSpinner, className, spinnerColor, dataTestId, ...restProps }: LoadingIndicatorProps): JSX.Element;
+export default LoadingIndicator;

package/dist/components/MediaPicker/ImageCategory.d.ts

@@ -0,0 +1,14 @@
+import React, { MouseEventHandler } from "react";
+export interface CategoryProps {
+    folder: string;
+    key: string;
+}
+interface ImageCategoryProps {
+    category: CategoryProps;
+    images: string[];
+    highlightedImage: string | null;
+    handleImageClick: MouseEventHandler<HTMLSpanElement>;
+    isTypeCompact: boolean;
+}
+export declare const ImageCategory: (props: ImageCategoryProps) => React.JSX.Element;
+export {};

package/dist/components/MediaPicker/MediaPicker.d.ts

@@ -0,0 +1,95 @@
+import React from "react";
+import { CategoryProps } from "./ImageCategory";
+export interface TargetProps {
+    target: {
+        name: string | null | undefined;
+        /**
+         * It is called imageData, but it can any file that was selected. The name is kept for backwards compatibility for now.
+         */
+        value: string | null | undefined | {
+            imageData: FormData;
+        };
+    };
+}
+export interface ImagePickerProps {
+    name: string;
+    images: string[];
+    categories: CategoryProps[];
+    preselectedImage?: string;
+    preselectedMediaType?: "image" | "video";
+    /**
+     * Array of [valid MIME types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types).
+     *
+     * If the media the user tries to upload doesn't match one of the
+     * MIME types in this array, an error message will be displayed in
+     * the UI.
+     *
+     * @example
+     * ```tsx
+     * <MediaPicker acceptedMimeTypes={[ "text/*", "image/jpeg", "video/mp4"]} />
+     * ```
+     */
+    acceptedMimeTypes?: string[];
+    /**
+     * Maximum file size allowed to be uploaded in MB. If undefined, a default limit of 100mb is applied.
+     */
+    maxFileSize?: number;
+    clearImageIndex?: number;
+    type?: "normal" | "compact";
+    isDisabled?: boolean;
+    handleChange: (target: TargetProps) => void;
+    isUploadButtonVisible?: boolean;
+    isClearButtonVisible?: boolean;
+    isUploading?: boolean;
+    isErrorUploading?: boolean;
+    localisation: Partial<Record<"openModalButton" | "selectButton" | "error" | "uploadImage" | "clearSelection" | "cancel" | "search" | "unsupportedMediaType" | "modalTitle", string>>;
+}
+export declare const ImagePickerInner: React.FC<ImagePickerProps & {
+    innerRef?: React.Ref<HTMLButtonElement>;
+}>;
+/**
+ * @deprecated Use MediaPicker instead
+ */
+export declare const ImagePicker: React.ForwardRefExoticComponent<ImagePickerProps & React.RefAttributes<HTMLButtonElement>>;
+export interface MediaPickerProps {
+    name: string;
+    media: string[];
+    categories: CategoryProps[];
+    /**
+     * If you add preselectedMedia you must also specify preselectedMediaType, especially if it is not an image.
+     *
+     * @example
+     * ```tsx
+     * <MediaPicker preselectedMedia="http://www.domain.com/someVideo.mp4" preselectedMediaType="video"/>
+     * ```
+     */
+    preselectedMedia?: string;
+    preselectedMediaType?: "image" | "video";
+    clearIndex?: number;
+    type?: "normal" | "compact";
+    /**
+     * Array of [valid MIME types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types).
+     *
+     * If the media the user tries to upload doesn't match one of the
+     * MIME types in this array, an error message will be displayed in
+     * the UI.
+     *
+     * @example
+     * ```tsx
+     * <MediaPicker acceptedMimeTypes={[ "text/*", "image/jpeg", "video/mp4"]} />
+     * ```
+     */
+    acceptedMimeTypes?: string[];
+    /**
+     * Maximum file size allowed to be uploaded in MB. If undefined, a default limit of 100mb is applied.
+     */
+    maxFileSize?: number;
+    isDisabled?: boolean;
+    onChange: (target: TargetProps) => void;
+    isUploadButtonVisible?: boolean;
+    isClearButtonVisible?: boolean;
+    isUploading?: boolean;
+    isErrorUploading?: boolean;
+    localisation: Partial<Record<"openModalButton" | "selectButton" | "error" | "upload" | "clearSelection" | "cancel" | "search" | "unsupportedMediaType" | "modalTitle", string>>;
+}
+export declare const MediaPicker: (props: MediaPickerProps) => React.JSX.Element;

package/dist/components/Modal/FullPageModal.d.ts

@@ -0,0 +1,39 @@
+import React from "react";
+import { PrimaryButtonProps } from "../ButtonV2/ButtonProps.type";
+import { FullPageModalActions } from "./subcomponents/FullPageModalActions";
+export type FullPageModalProps = {
+    children: React.ReactNode;
+    isOpen?: boolean;
+    title: string;
+    dataTestId?: string;
+    /**
+     * @deprecated
+     * Use the `actions` prop to render any button(s)
+     * or other component(s) automatically in the correct area.
+     *
+     * This prop will only render a button when the actions prop is omitted.
+     * The actions prop takes precedence over this prop if they're both passed.
+     */
+    primaryButtonProps?: PrimaryButtonProps;
+    /**
+     * Render buttons or other action components in the area meant for actions.
+     * To correctly space out the actions wrap them in a FullPageModal.Actions component.
+     * @usage
+     * ```tsx
+     * <FullPageModal
+     *   actions={
+     *     <FullPageModal.Actions>
+     *       <PrimaryButton />
+     *       <SecondaryButton />
+     *     </FullPageModal.Actions>
+     *   }
+     * />
+     */
+    actions?: React.ReactNode;
+    onCloseClick: (event: React.MouseEvent<Element, MouseEvent> | React.KeyboardEvent<Element>) => void;
+};
+interface StaticComponents {
+    Actions: typeof FullPageModalActions;
+}
+export declare const FullPageModal: React.FC<FullPageModalProps> & StaticComponents;
+export {};

package/dist/components/Modal/FullPageModalHeader.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { PrimaryButtonProps } from "../ButtonV2/ButtonProps.type";
+export type FullPageModalHeaderProps = {
+    title: string;
+    /**
+     * @deprecated
+     * Use the `actions` prop to render any button(s)
+     * or other component(s) automatically in the correct area.
+     */
+    primaryButtonProps?: PrimaryButtonProps;
+    actions?: React.ReactNode;
+};
+export declare const FullPageModalHeader: React.FC<FullPageModalHeaderProps>;

package/dist/components/Modal/Modal.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+import { ModalBaseProps } from "./ModalBase";
+export type ModalProps = Omit<ModalBaseProps, "title" | "withExtraMarginTop"> & {
+    title: string;
+};
+export declare const Modal: React.FC<ModalProps>;

package/dist/components/Modal/ModalBase.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import { ModalHeaderProps } from "./ModalHeader";
+import { ModalFooterProps } from "./ModalFooter";
+export type ModalSize = "small" | "medium" | "wide";
+export type ModalBaseProps = Omit<ModalHeaderProps, "title"> & {
+    children: React.ReactNode;
+    size?: ModalSize;
+    withExtraMarginTop?: boolean;
+    withContentPaddingY?: boolean;
+    isOpen?: boolean;
+    title?: string;
+    dataTestId?: string;
+    scrollableContent?: boolean;
+    onCloseClick: (event: React.MouseEvent<Element, MouseEvent> | React.KeyboardEvent<Element>) => void;
+} & ModalFooterProps;
+export declare const ModalBase: React.FC<ModalBaseProps>;

package/dist/components/Modal/ModalFooter.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import { ButtonWithPendingStateProps, NonPrimaryButtonProps, PrimaryButtonProps } from "../ButtonV2/ButtonProps.type";
+export interface ModalFooterTrailingComponents {
+    primaryButtonProps: PrimaryButtonProps;
+    secondaryButtonProps?: NonPrimaryButtonProps;
+}
+export type ModalFooterLeadingComponent = string | ButtonWithPendingStateProps;
+export type ModalFooterProps = {
+    footerLeadingComponent?: ModalFooterLeadingComponent;
+    footerTrailingComponents: ModalFooterTrailingComponents;
+};
+export declare const ModalFooter: React.FC<ModalFooterProps>;

package/dist/components/Modal/ModalHeader.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export type ModalHeaderProps = {
+    title: string;
+    onCloseClick: (event: React.MouseEvent<HTMLButtonElement>) => void;
+};
+export declare const ModalHeader: React.FC<ModalHeaderProps>;

package/dist/components/Modal/subcomponents/FullPageModalActions.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+/**
+ * Use in the actions of a FullPageModal. Spaces out the action
+ * components correctly in relation to the styling of the FullPageModal component.
+ *
+ * @usage
+ * ```tsx
+ * <FullPageModal
+ *   actions={
+ *     <FullPageModal.Actions>
+ *       <PrimaryButton />
+ *       <SecondaryButton />
+ *     </FullPageModal.Actions>
+ *   }
+ * />
+ * ```
+ */
+export declare const FullPageModalActions: React.FC<React.PropsWithChildren>;

package/dist/components/NavMenu/NavLayout.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+export interface NavMenuLayoutProps {
+    menu: React.ReactNode;
+    children: JSX.Element | JSX.Element[];
+    patientSidebar?: JSX.Element;
+    isNavDisabled?: boolean;
+    disableScrolling?: boolean;
+}
+/**
+ *
+ * @param props {NavMenuLayoutProps} - explaining specifically the `disableScrolling` prop:
+ *
+ * The patient overview page has some challenges we want to overcome in regards to the multiple scrollable
+ * content (the charts and the action bar with alerts, etc).
+ *
+ * In order to have the setup working on the patient overview page and the rest of the application, we have to
+ * progamatically disable/enable if that location will have a normal scrolling mechanism with specific margin/padding,
+ * or we will need to let the components take care of that.
+ */
+export declare const NavLayout: (props: NavMenuLayoutProps) => JSX.Element;

package/dist/components/NavMenu/NavMenu.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { NavMenuFooterProps } from "./types/NavMenuFooterProps.type";
+import { NavMenuItemProps } from "./types/NavMenuItemProps.type";
+import { NavMenuHeaderProps } from "./types/NavMenuHeaderProps.type";
+export type NavMenuProps = {
+    roleItems: NavMenuItemProps[];
+    publicItems: NavMenuItemProps[];
+    authenticationItems: {
+        login: NavMenuItemProps;
+        logout: NavMenuItemProps;
+    };
+    isUserAuthenticated?: boolean;
+    navMenuHeaderProps: NavMenuHeaderProps;
+    navMenuFooterProps: NavMenuFooterProps;
+};
+export declare function NavMenu(props: NavMenuProps): JSX.Element;

package/dist/components/NavMenu/NavMenuContent.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { NavMenuProps } from "./NavMenu";
+export declare const NavMenuContent: React.FC<NavMenuProps>;

package/dist/components/NavMenu/NavMenuFooter.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { NavMenuFooterProps } from "./types/NavMenuFooterProps.type";
+export declare const NavMenuFooter: React.FC<NavMenuFooterProps>;

package/dist/components/NavMenu/NavMenuHeader.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { NavMenuHeaderProps } from "./types/NavMenuHeaderProps.type";
+export declare const NavMenuHeader: React.FC<NavMenuHeaderProps>;

package/dist/components/NavMenu/NavMenuItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { NavMenuItemProps } from "./types/NavMenuItemProps.type";
+export declare const NavMenuItem: (props: NavMenuItemProps) => JSX.Element;

package/dist/components/NavMenu/types/NavMenuFooterProps.type.d.ts

@@ -0,0 +1,5 @@
+export interface NavMenuFooterProps {
+    text: string;
+    subtext?: string;
+    visible?: boolean;
+}

package/dist/components/NavMenu/types/NavMenuHeaderProps.type.d.ts

@@ -0,0 +1,5 @@
+export interface NavMenuHeaderProps {
+    text: string;
+    visible?: boolean;
+    onClick?: () => void;
+}

package/dist/components/NavMenu/types/NavMenuItemProps.type.d.ts

@@ -0,0 +1,11 @@
+export type NavMenuItemProps = {
+    href?: string;
+    linkTo?: string;
+    title: string;
+    isSelected: boolean;
+    img: string;
+    imgOnHover: string;
+    dataTestId: string;
+    isExternal?: boolean;
+    trackEvent?: () => void;
+};

package/dist/components/NotificationBanner/NotificationBanner.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+import { IconProps } from "../Icons/types/IconProps.type";
+import "./NotificationBanner.css";
+export type NotificationBannerColor = "base" | "blue" | "red" | "green" | "amber";
+export interface NotificationBannerLinkProps {
+    text: string;
+    enabled: boolean;
+    handleClick?: () => void;
+}
+interface NotificationBannerPropsWithText {
+    text?: string;
+    linkProps?: NotificationBannerLinkProps;
+    children?: never;
+}
+interface NotificationBannerPropsWithChildren {
+    children: React.ReactNode;
+    text?: never;
+    linkProps?: never;
+}
+export type NotificationBannerProps = (NotificationBannerPropsWithChildren | NotificationBannerPropsWithText) & {
+    color?: NotificationBannerColor;
+    /**
+     * The icon can either be one of our icon components or an image url
+     */
+    icon?: string | React.FunctionComponent<IconProps>;
+    className?: string;
+    stretch?: boolean;
+    /**
+     * When stretching the banner, you can also decide if the content should be centered or not.
+     */
+    centerContent?: boolean;
+    noBorder?: null | boolean;
+};
+export declare const NotificationBanner: {
+    (props: NotificationBannerProps): JSX.Element;
+    defaultProps: {
+        color: string;
+        onButtonClick: undefined;
+    };
+};
+export {};

package/dist/components/Page/CRUDPage.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import type { CRUDPageProps } from "./CRUDPage.types";
+declare const CRUDPage: React.FC<CRUDPageProps>;
+export default CRUDPage;