@luscii-healthtech/web-ui 0.0.0-alpha.01cea45

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,91 @@
+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>;
+}>;
+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: React.ForwardRefExoticComponent<MediaPickerProps & React.RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,41 @@
+import React from "react";
+import ReactModal from "react-modal";
+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;
+    setAppElement: typeof ReactModal.setAppElement;
+}
+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,11 @@
+import React from "react";
+import ReactModal from "react-modal";
+import { ModalBaseProps } from "./ModalBase";
+export type ModalProps = Omit<ModalBaseProps, "title" | "withExtraMarginTop"> & {
+    title: string;
+};
+interface StaticProperties {
+    setAppElement: typeof ReactModal.setAppElement;
+}
+export declare const Modal: React.FC<ModalProps> & StaticProperties;
+export {};

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,35 @@
+import React from "react";
+export interface Props extends React.ComponentPropsWithoutRef<"div"> {
+    menu: React.ReactNode;
+    /**
+     * This property is used everywhere BUT in PatientPages.js, because the layout there works very differently than
+     * in the other pages. With JavaScript calculations for heights, etc to make sure everything fits.
+     */
+    pageHeader?: JSX.Element;
+    /**
+     * Rendered as the main page content.
+     */
+    children: React.ReactNode;
+    /**
+     * If passed will show the patients sidebar.
+     */
+    patientSidebar?: JSX.Element | null;
+    /**
+     * Don't show any navigation, for instance when constrained to a single patient.
+     */
+    isNavDisabled?: boolean;
+    /**
+     * 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
+     * programmatically 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.
+     */
+    disableScrolling?: boolean;
+    /**
+     * Whether the layout is rendering in the viewer. Usually the result of the `useInViewer` hook.
+     */
+    isInViewer?: boolean;
+}
+export declare const NavLayout: React.FC<Props>;

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,11 @@
+/// <reference types="react" />
+export interface NavMenuHeaderProps {
+    text: string;
+    /**
+     * Optional content to be displayed underneath the header text, matching the left spacing and a 4px top padding
+     * against the header text.
+     */
+    belowHeader?: JSX.Element;
+    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: "base";
+        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;

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

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import type { BaseButtonProps } from "../ButtonV2/ButtonProps.type";
+import type { PageHeaderProps } from "../PageHeader";
+import type { StepsProps } from "../Steps/Steps";
+type CRUDPageButtonProps = Pick<BaseButtonProps, "onClick" | "text" | "isDisabled">;
+type CRUDPageTitle = {
+    text: string;
+    icon?: string;
+};
+type CRUDPageHeader = Omit<PageHeaderProps, "navigation" | "isPolling" | "accessories">;
+type CRUDPagePropsWithoutHeaderOrTitle = {
+    dataTestId?: string;
+    submitButtonProps?: CRUDPageButtonProps;
+    cancelButtonProps?: CRUDPageButtonProps;
+    className?: string;
+    isLoading?: boolean;
+    isSubmitting?: boolean;
+    children?: React.ReactNode;
+    steps?: {
+        titles: StepsProps["orderedStepTitles"];
+        currentStep: StepsProps["currentStep"];
+        localization: StepsProps["localization"];
+    };
+};
+export type CRUDPageProps = (CRUDPagePropsWithoutHeaderOrTitle & {
+    title: CRUDPageTitle;
+    header?: never;
+}) | (CRUDPagePropsWithoutHeaderOrTitle & {
+    header: CRUDPageHeader;
+    title?: never;
+});
+export {};

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

@@ -0,0 +1,3 @@
+export { default as Page } from "./Page";
+export { default as CRUDPage } from "./CRUDPage";
+export type { CRUDPageProps } from "./CRUDPage.types";

package/dist/components/PageHeader/PageHeader.d.ts

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

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

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+import type { BreadcrumbProps } from "../Breadcrumbs";
+import { NotificationBannerColor } from "../NotificationBanner/NotificationBanner";
+import type { TabbarProps } from "../Tabbar/Tabbar";
+type Nil = null | undefined;
+type WithPageHeaderBanner = {
+    banner: Nil | {
+        title?: string;
+        text: {
+            content: string;
+            isHTML?: boolean;
+        };
+        color: NotificationBannerColor;
+        noBorder?: boolean | null;
+    };
+};
+export type PageHeaderProps = {
+    navigation?: Omit<TabbarProps, "withoutPadding">;
+    breadcrumbs?: BreadcrumbProps["crumbs"];
+    truncateBreadcrumbsAfter?: number;
+    dataTestId?: string;
+    title: string;
+    isPolling?: boolean;
+    className?: string;
+    contained?: boolean;
+    accessories?: React.ReactNode;
+} & WithPageHeaderBanner;
+export {};

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

@@ -0,0 +1,2 @@
+export { default as PageHeader } from "./PageHeader";
+export type { PageHeaderProps } from "./PageHeader.types";

package/dist/components/PaginationMenu/PaginationMenu.d.ts

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

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

@@ -0,0 +1,37 @@
+export interface PaginationMenuProps {
+    pageCount: number;
+    currentPageNumber: number;
+    onChange: OnPaginationChange;
+    pageSize?: PageSize;
+    localization?: Localization;
+    resultCount?: number;
+    small?: boolean;
+    className?: string;
+}
+export interface PaginationMenuSmallProps {
+    pageCount: number;
+    currentPageNumber: number;
+    onChange: OnPaginationChange;
+    pageSize?: PageSize;
+}
+export interface PaginationMenuLargeProps {
+    pageCount: number;
+    currentPageNumber: number;
+    onChange: OnPaginationChange;
+    pageSize?: PageSize;
+    localization: Localization;
+    resultCount?: number;
+}
+export type OnPaginationChange = (pageNumber: number, pageSize?: PageSize) => void;
+export type PageSize = 25 | 50 | 75 | 100;
+export interface Localization {
+    display: string;
+    page: string;
+    previous: string;
+    next: string;
+    of: string;
+}
+export type Option = {
+    value: number;
+    label: string;
+};

package/dist/components/PaginationMenu/PaginationMenu.utils.d.ts

@@ -0,0 +1,15 @@
+import { Localization, Option, PageSize } from "./PaginationMenu.types";
+export declare const PAGE_SIZE_OPTIONS: {
+    label: string;
+    value: PageSize;
+}[];
+export declare const getPageNumberOptions: (pageCount: number) => Option[];
+/**
+ *
+ * @returns When the pageSize and resultCount params are present,
+ * this function returns a text indicating the range of elements that are being displayed,
+ * otherwise it returns a text indicating the current page and the page count.
+ * @example 1-50 of 100
+ *
+ */
+export declare const getSummaryText: (pageCount: number, currentPageNumber: number, localization: Localization, pageSize?: number, resultCount?: number) => string;

package/dist/components/PaginationMenu/PaginationMenuLarge.d.ts

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

package/dist/components/PaginationMenu/PaginationMenuSmall.d.ts

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

package/dist/components/PreviewPhone/PreviewPhone.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface PreviewPhoneProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare const PreviewPhone: ({ className, children, }: PreviewPhoneProps) => JSX.Element;
+export default PreviewPhone;

package/dist/components/Radio/RadioV2.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import "./RadioV2.css";
+export interface RadioProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    name: string;
+    value: string | number;
+    text?: string;
+    info?: string;
+    isError?: boolean;
+    innerRef?: React.Ref<HTMLInputElement>;
+}
+/**
+ * TODO: The CSS styling is all messed up, including isError
+ * Warning: don't use this prop before this is resolved
+ * Issue to track: https://github.com/Luscii/web-ui/issues/57
+ * TODO: remove this comment once this is resolved
+ */
+export declare const RadioV2: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/RadioGroup/RadioGroupV2.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { RadioProps } from "../Radio/RadioV2";
+export interface RadioGroupProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "name" | "value" | "checked"> {
+    name: string;
+    isError?: boolean;
+    options: Omit<RadioProps, "name">[];
+    innerRef?: React.Ref<HTMLInputElement>;
+    title?: string;
+}
+export declare const RadioGroupV2: React.ForwardRefExoticComponent<RadioGroupProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/Section/Section.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import { ButtonProps } from "../Button/Button.types";
+import { LoadingIndicatorProps } from "../LoadingIndicator/LoadingIndicator";
+import { RestPropped } from "../../types/general.types";
+import "./Section.scss";
+export interface SectionProps extends RestPropped {
+    title?: string;
+    /**
+     * @deprecated
+     * Use the `headerAside` prop to render any button(s)
+     * or other component(s) automatically in the correct area.
+     */
+    buttons?: ButtonProps[];
+    footer?: React.ReactNode;
+    className?: string;
+    isLoading?: boolean;
+    loadingIndicatorProps?: LoadingIndicatorProps;
+    children?: React.ReactNode;
+    /**
+     * Rendered opposite of the `title`.
+     */
+    headerAside?: React.ReactNode;
+}
+export declare function Section({ title, buttons, footer, children, headerAside, className, isLoading, loadingIndicatorProps, ...restProps }: SectionProps): JSX.Element;
+export default Section;