wjec-one 3.10.24 → 4.0.0-alpha.2

package/index.d.ts

@@ -1,56 +1,1567 @@
-export { default as ColorPalette } from './src/ColorPalette';
-export { default as ColorPaletteEduqas } from './src/ColorPaletteEduqas';
-export { default as StylePalette } from './src/StylePalette';
-export * from './src/components/Accordion';
-export * from './src/components/Breadcrumb';
-export * from './src/components/buttons/Button';
-export * from './src/components/buttons/DestructiveButton';
-export * from './src/components/buttons/IconButton';
-export * from './src/components/buttons/LinkButton';
-export * from './src/components/buttons/PrimaryButton';
-export * from './src/components/Card';
-export * from './src/components/Carousel';
-export * from './src/components/CheckBox';
-export * from './src/components/CircularProgress';
-export * from './src/components/ContextHelp';
-export * from './src/components/ContextMenu';
-export * from './src/components/DateTimePicker';
-export * from './src/components/DragAndDropList';
-export * from './src/components/Email';
-export * from './src/components/Emphasis';
-export * from './src/components/FileInput';
-export * from './src/components/FilterList';
-export * from './src/components/Form';
-export * from './src/components/Input';
-export * from './src/components/layout/Footer';
-export * from './src/components/layout/Header';
-export * from './src/components/layout/Page';
-export * from './src/components/LinearProgress';
-export * from './src/components/Link';
-export * from './src/components/LocalizationMenu';
-export * from './src/components/Modal';
-export * from './src/components/notifications/Notification';
-export * from './src/components/notifications/ErrorNotification';
-export * from './src/components/notifications/InfoNotification';
-export * from './src/components/notifications/SuccessNotification';
-export * from './src/components/PageTitle';
-export * from './src/components/Pagination';
-export * from './src/components/Paragraph';
-export * from './src/components/Password';
-export * from './src/components/Popup';
-export * from './src/components/PopupWindow';
-export * from './src/components/PrintLayout';
-export * from './src/components/PrintWindow';
-export * from './src/components/RadioGroup';
-export * from './src/components/ScrollableContainer';
-export * from './src/components/SectionHeading';
-export * from './src/components/SectionTitle';
-export * from './src/components/Select';
-export * from './src/components/SigninForm';
-export * from './src/components/SigninMenu';
-export * from './src/components/SubParagraph';
-export * from './src/components/SubTitle';
-export * from './src/components/Table';
-export * from './src/components/Tabs';
-export * from './src/components/TextArea';
-export * from './src/components/Toggle';
+/// <reference types="react" />
+import { Interpolation, ArrayInterpolation } from '@emotion/core';
+import * as _emotion_utils from '@emotion/utils';
+import * as React$1 from 'react';
+import React__default, { Dispatch, SVGProps, ButtonHTMLAttributes, CSSProperties, FC, InputHTMLAttributes, MouseEvent, Context } from 'react';
+import { AriaButtonProps } from 'react-aria';
+import { GapProperty, BottomProperty, LeftProperty, RightProperty, TopProperty, ColorProperty, WidthProperty, HeightProperty, PositionProperty, MarginProperty, PaddingProperty } from 'csstype';
+import { Record } from 'immutable';
+
+declare type ColorPalette = {
+    border: string;
+    entryLevel: string;
+    errorBackground: string;
+    error: string;
+    errorDark: string;
+    errorDarker: string;
+    font: string;
+    fontLight: string;
+    gceALevel: string;
+    gceASLevel: string;
+    gcse: string;
+    highlight: string;
+    neutral: string;
+    neutralDark: string;
+    neutralLight: string;
+    offBlack: string;
+    offWhite: string;
+    otherQualifications: string;
+    primary: string;
+    primaryDark: string;
+    primaryDarkActive: string;
+    primaryLight: string;
+    primaryLightActive: string;
+    secondary: string;
+    secondaryDark: string;
+    secondaryDarkActive: string;
+    secondaryLight: string;
+    secondaryLightActive: string;
+    success: string;
+    successBackground: string;
+    successDark: string;
+    successDarker: string;
+    tertiary: string;
+    vQAward: string;
+    warningBackground: string;
+    warning: string;
+    warningDark: string;
+    welshBaccAdvanced: string;
+    welshBaccFoundation: string;
+    welshBaccNational: string;
+    welshBaccKS4: string;
+};
+declare type Styles = Interpolation | ArrayInterpolation<any>;
+
+declare const _default$2: ColorPalette;
+
+declare const _default$1: ColorPalette;
+
+declare const _default: Readonly<{
+    borderRadius: "4px";
+    dropShadow: `0px 2px 10px ${string}`;
+    scrollbar: _emotion_utils.SerializedStyles;
+    visiblyHidden: _emotion_utils.SerializedStyles;
+}>;
+
+declare type WjecOneComponentProps<P = {}> = React$1.PropsWithChildren<P & {
+    /** The identifier that will be passed through to the underlying HTML element */
+    id?: string;
+}>;
+declare type WjecOneComponent<P = {}> = React$1.FunctionComponent<WjecOneComponentProps<P>>;
+
+/** @jsx jsx */
+
+declare type Props$I = {
+    expanded?: boolean;
+    onClick?: (isExpanded: boolean) => void;
+    spacing?: 'normal' | 'small';
+    title: string | React__default.ReactElement;
+};
+declare const AccordionContent: WjecOneComponent<Props$I>;
+
+declare type Props$H = {
+    exclusive?: boolean;
+    spacing?: 'normal' | 'small';
+};
+interface AccordionComponent extends WjecOneComponent<Props$H> {
+    Content: typeof AccordionContent;
+}
+declare const Accordion: AccordionComponent;
+
+declare type Action = AsyncAction | SimpleAction;
+declare type AsyncAction = (dispatch: Dispatch<Action>, state: DestructurableRecord<any>) => void | Promise<void>;
+declare type DestructurableRecord<T extends {}> = Record<T> & {
+    [K in keyof T]: T[K];
+};
+declare type SimpleAction = {
+    payload?: any;
+    type: string;
+};
+
+declare type GenericStrings = {
+    [key: string]: string;
+};
+declare type LocalizationState<L extends number | string | symbol = any, S extends GenericStrings = any> = {
+    availableLocales: L[];
+    locale: L;
+    strings: S;
+};
+declare type FormattedPart = React__default.ReactElement<{
+    children?: Array<string | number | FormattedPart>;
+}, any>;
+declare type FormattedString = string | number | FormattedPart;
+
+declare type SVGComponent = React__default.ReactElement<SVGProps<SVGSVGElement>>;
+declare type ContentExtractor<T> = keyof T | ((obj: T, index?: number) => string | JSX.Element | T[keyof T]);
+declare type KeyExtractor<T> = keyof T | ((obj: T, index?: number) => number | string);
+
+declare type AriaProperties = {
+    ariaCurrent?: 'page' | 'step';
+    ariaDescription?: string;
+    ariaExpanded?: boolean;
+    ariaHidden?: boolean;
+    ariaLabel?: string;
+    ariaMultiselectable?: boolean;
+    ariaPosInSet?: number;
+    ariaRole?: string;
+    ariaSetSize?: number;
+    ariaSort?: 'ascending' | 'descending';
+};
+
+declare type Props$G<T> = {
+    breadcrumbs: T[];
+    keyExtractor?: KeyExtractor<T>;
+    labelExtractor?: ContentExtractor<T>;
+    onClick: (crumb: string) => void;
+    showCurrent?: boolean;
+} & Pick<AriaProperties, 'ariaCurrent'>;
+declare const Breadcrumb: <T extends {}>({ breadcrumbs, id, keyExtractor, labelExtractor, onClick, showCurrent }: WjecOneComponentProps<Props$G<T>>) => JSX.Element;
+
+declare type ButtonAccessibilityProps = {
+    /** An id that identifies the element (or elements) whose contents or presence are controlled by the Button */
+    controls?: AriaButtonProps['aria-controls'];
+    /** Indicates whether the Button, or another component it controls, is currently expanded or collapsed */
+    expanded?: AriaButtonProps['aria-expanded'];
+    /** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by the Button */
+    hasPopup?: AriaButtonProps['aria-haspopup'];
+};
+declare type ButtonBehaviorProps = {
+    /**
+     * Determines whether the browser's onClick event is propagated beyond the component
+     * @default false
+     */
+    allowEventPropagation?: boolean;
+    /**
+     * Determines the behavior of the Button when used in an HTML form
+     * @default "button"
+     */
+    buttonType?: ButtonHTMLAttributes<HTMLButtonElement>['type'];
+    /**
+     * Determines whether the Button is subject to user interaction
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * An SVG component that will be rendered as the Button's icon. An icon must be provided if no label is provided
+     */
+    icon?: (props: SVGProps<SVGSVGElement>) => SVGComponent;
+    /**
+     * Determines which side of the Button the SVG icon component is positioned in relation to the Button's label text
+     * @default "left"
+     */
+    iconPosition?: 'left' | 'right';
+    /** Determines whether the Button should render a loading animation to indicate activity */
+    loading?: boolean;
+    /** Determines the progress % to be represented by the loading animation. If no value is provided, the loading animation will loop in an infinite, indeterminate state */
+    loadingProgress?: number;
+    /** A handler that will be called when the Button is pressed */
+    onPress?: () => void;
+};
+declare type ButtonElementProps = {
+    /** Text that will be displayed as the Button's label (Note: a more complex label can be achieved by instead providing the label as the Button's children). A label must be provided if no icon is provided */
+    label?: FormattedString;
+};
+declare type ButtonStyleProps = {
+    /** Determines the color of the Button's background when active */
+    activeColor?: CSSProperties['color'];
+    /**
+    * Determines the color of the Button's border
+    * @default "transparent"
+    */
+    borderColor?: CSSProperties['color'];
+    /**
+     * Determines the color of the Button's background
+     * @default ColorPalette.neutral
+     * */
+    color?: CSSProperties['color'];
+    /**
+     * Determines the color of the Button's background when focused. If undefined, this will default to the value of color
+     */
+    focusColor?: CSSProperties['color'];
+    /**
+     * Determines the color of the Button's background when hovered
+     * @default ColorPalette.border
+     */
+    hoverColor?: CSSProperties['color'];
+    /**
+     * Determines the color of the provided SVG icon component. If undefined, this will default to the value of labelColor
+     */
+    iconColor?: CSSProperties['color'];
+    /**
+     * Determines the color of the provided SVG icon component when the Button is active. The specified color should have sufficient contrast with the active background color for accessibility purposes. If undefined, this will default to the value of labelColorActive
+     */
+    iconColorActive?: CSSProperties['color'];
+    /**
+     * Determines the color of the Button's label text (and icon, unless otherwise specified)
+     * @default ColorPalette.neutralDark
+     */
+    labelColor?: CSSProperties['color'];
+    /**
+     * Determines the colour of the Button's label text when active. The specified color should have sufficient contrast with the active background color for accessibility purposes
+     * @default #FFFFFF
+     */
+    labelColorActive?: CSSProperties['color'];
+    /**
+     * Determines the color of the Button's outline when focused. The specified color should have sufficient contrast with the background color for accessibility purposes
+     * @default ColorPalette.primary
+     */
+    outlineColor?: CSSProperties['color'];
+    /**
+     * Determines the rendered size of the Button but adjusting the amount of padding
+     * @default "normal"
+     */
+    size?: 'small' | 'normal' | 'large';
+};
+declare type DeprecatedButtonProps = {
+    /**
+     * Determines whether the Button is rendered in a "filled" style (solid background color) or a "transparent" style (colored border)
+     * @default "filled"
+     * @deprecated buttonStyle has been deprecated for design reasons; Button components will now always behave as though `buttonStyle='filled'`
+     * */
+    buttonStyle?: 'filled' | 'transparent';
+    /**
+     * Determines the rendered size of the provided SVG icon component
+     * @default "normal"
+     * @deprecated iconSize has been deprecated for design reasons. Button components will now always behave as though `iconSize='normal'`
+     */
+    iconSize?: 'small' | 'normal' | 'large';
+    /**
+     * Determines the color of the loading indicator when displayed
+     * @deprecated loadingColor has been deprecated for design reasons. The labelColor will now be used for the loading animation
+     */
+    loadingColor?: CSSProperties['color'];
+    /**
+     * A handler that is called when the underlying HTML element's onClick event is triggered
+     * @deprecated onClick has been deprecated in favor of the new onPress prop, which behaves similarly but with better accessibility support
+    */
+    onClick?: () => void;
+    /**
+     * Determines whether to show an outline around the Button when it receives focus
+     * @default true
+     * @deprecated This prop is no longer supported for accessibility reasons. The Button component will now behave as though showOutline={true} in all cases
+     */
+    showOutline?: boolean;
+};
+declare type ButtonProps$6 = {
+    accessibility?: ButtonAccessibilityProps;
+} & ButtonBehaviorProps & ButtonElementProps & ButtonStyleProps & Pick<AriaProperties, 'ariaLabel'> & DeprecatedButtonProps;
+
+declare const Button: WjecOneComponent<ButtonProps$6>;
+
+declare type ButtonProps$5 = React__default.ComponentProps<typeof Button>;
+declare type Props$F = Omit<ButtonProps$5, 'activeColor' | 'borderColor' | 'color' | 'focusColor' | 'hoverColor' | 'iconColor' | 'iconColorActive' | 'labelColor' | 'labelColorActive' | 'outlineColor'>;
+declare const DestructiveButton: FC<Props$F>;
+
+declare type ButtonProps$4 = React__default.ComponentProps<typeof Button>;
+interface Props$E extends Omit<ButtonProps$4, 'activeColor' | 'children' | 'color' | 'hoverColor' | 'iconPosition' | 'label'> {
+    icon: ButtonProps$4['icon'];
+}
+declare const IconButton: FC<Props$E>;
+
+declare type ButtonProps$3 = React__default.ComponentProps<typeof Button>;
+declare type Props$D = Omit<ButtonProps$3, 'activeColor' | 'buttonType' | 'color' | 'hoverColor' | 'iconPosition'>;
+declare const LinkButton: FC<Props$D>;
+
+declare type ButtonProps$2 = React__default.ComponentProps<typeof Button>;
+declare type Props$C = Omit<ButtonProps$2, 'activeColor' | 'borderColor' | 'color' | 'focusColor' | 'hoverColor' | 'iconColor' | 'iconColorActive' | 'labelColor' | 'labelColorActive' | 'outlineColor'>;
+declare const PrimaryButton: FC<Props$C>;
+
+declare type ButtonProps$1 = React__default.ComponentProps<typeof Button>;
+declare type Props$B = Omit<ButtonProps$1, 'activeColor' | 'borderColor' | 'color' | 'focusColor' | 'hoverColor' | 'iconColor' | 'iconColorActive' | 'labelColor' | 'labelColorActive' | 'outlineColor'>;
+declare const SecondaryButton: FC<Props$B>;
+
+declare type Props$A = {
+    padding?: CSSProperties['padding'];
+} & Pick<AriaProperties, 'ariaDescription'>;
+declare const Card: WjecOneComponent<Props$A>;
+
+declare type CarouselControls = {
+    goToNextSlide: () => void;
+    goToPreviousSlide: () => void;
+    goToSlide: (index: number) => void;
+};
+declare type CarouselProps = {
+    /**
+     * The number of extra slides to render at either end of the Carousel when using infinite rotation
+     * @default 2
+     */
+    buffer?: number;
+    /** Determines whether the Carousel should loop around to the start/end when navigating beyond the first/last slides */
+    infinite?: boolean;
+    /** A handler that is called when the active slide index is changed */
+    onChange?: (slideIndex: number) => void;
+    /**
+     * Determines whether to display the built-in next/previous slide navigation button controls
+     * @default true
+     */
+    showNavigationButtons?: boolean;
+    /**
+     * Determines whether to display the built-in controls to indicate/select the active slide
+     * @default true
+     */
+    showNavigationDots?: boolean;
+    /** Determines whether a point-and-click device can be used to simulate the touch swipe gesture to navigate between slides */
+    simulateMouseSwipe?: boolean;
+    /**
+     * The index of the active slide
+     * @default 0
+     */
+    slideIndex?: number;
+    /**
+     * The duration (in milliseconds) of the transition between slides
+     * @default 200
+     */
+    slideTransitionDuration?: number;
+};
+
+declare const Carousel: React__default.ForwardRefExoticComponent<CarouselProps & {
+    id?: string;
+} & {
+    children?: React__default.ReactNode;
+} & React__default.RefAttributes<CarouselControls>>;
+
+declare type Props$z = {
+    color?: CSSProperties['color'];
+    progress?: number;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const CircularProgress: WjecOneComponent<Props$z>;
+
+declare type Attachment = 'floating' | 'sibling';
+declare type Placement = 'bottom' | 'bottom-end' | 'bottom-start' | 'left' | 'left-end' | 'left-start' | 'right' | 'right-end' | 'right-start' | 'top' | 'top-end' | 'top-start';
+declare type Trigger = 'click' | 'hover' | 'press' | 'none';
+declare type PopupProps$2 = {
+    /**
+     * Determines whether the Popup is a sibling of the toggle, or "floating" above the entire document
+     * @default "sibling"
+     */
+    attachment?: Attachment;
+    /**
+     * Determines the background color of the Popup
+     * @default "#fff"
+     * */
+    backgroundColor?: CSSProperties['backgroundColor'];
+    /** The delay, in milliseconds, before the Popup closes in response to a "close" trigger from the toggle */
+    closeDelay?: number;
+    /** Determines whether the Popup should close if a click is detected outside of the toggle/Popup */
+    closeOnClickOutside?: boolean;
+    /** Determines whether the Popup should close if it is scrolled completely out of view */
+    closeOnOutOfView?: boolean;
+    /**
+     * The gap between the toggle and the Popup
+     * @deprecated gapSize has been deprecated in favor of the more standard margin prop
+     */
+    gapSize?: CSSProperties['margin'];
+    /**
+     * Determines the CSS margin property for the Popup's container element; primarily used to control the distance from the toggle
+     * @default "10px"
+     * */
+    margin?: CSSProperties['margin'];
+    /**
+     * Determines the maximum permitted height of the Popup
+     * @default "300px"
+     * */
+    maxHeight?: CSSProperties['maxHeight'];
+    /**
+     * Determines the maximum permitted width of the Popup
+     * @default "300px"
+     * */
+    maxWidth?: CSSProperties['maxWidth'];
+    /** A handler that is called whenever the Popup is hidden from view */
+    onHide?: () => void;
+    /** A handler that is called whenever the Popup becomes visible */
+    onShow?: () => void;
+    /** Determines whether the Popup should be visible */
+    open?: boolean;
+    /** A delay, in milliseconds, before the Popup opens in response to an "open" trigger from the toggle */
+    openDelay?: number;
+    /**
+     * Determines the CSS padding property for the Popup's container element
+     * @default "10px"
+     * */
+    padding?: CSSProperties['padding'];
+    /** Determines the position of the Popup in relation to the toggle */
+    placement?: Placement;
+    /**
+     * Determines the CSS position for the componment's container (including toggle)
+     * @default { left: 'auto', top: 'auto' }
+     * @deprecated position has been deprecated because WJEC One components are intended to be layout agnostic
+     * */
+    position?: Position;
+    /**
+     * Determines the horizontal alignment of the Popup in relation to the toggle
+     * @default "right"
+     * @deprecated popupPositionX and popupPositionY have been deprecated in favor of the new placement prop, which encompasses both
+     */
+    popupPositionX?: 'after' | 'before' | 'left' | 'right';
+    /**
+     * Determines the vertical alignment of the Popup in relation to the toggle
+     * @default "below"
+     * @deprecated popupPositionX and popupPositionY have been deprecated in favor of the new placement prop, which encompasses both
+     */
+    popupPositionY?: 'above' | 'below' | 'bottom' | 'top';
+    /**
+     * Determines the CSS position property for the component's container element (including toggle)
+     * @default "relative"
+     * @deprecated positionType has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    positionType?: 'absolute' | 'relative' | 'fixed';
+    /**
+     * Determines whether the Popup's content should be scrollable if it overflows on the vertical axis
+     * @default true
+     */
+    scrollable?: boolean;
+    /**
+     * A callback used to obtain the Popup container element's ref from the parent context
+     * @deprecated setRef has been deprecated as it is no longer required internally
+     */
+    setRef?: (ref: HTMLDivElement) => void;
+    /**
+     * Determines the color of the Popup's content
+     * @default ColorPalette.font
+     */
+    textColor?: CSSProperties['color'];
+    /** The string or component to use as the Popup's toggle */
+    toggle: string | React__default.ReactElement;
+    /**
+     * Determines the CSS cursor property to be applied to the toggle
+     * @default "pointer"
+     */
+    toggleCursor?: CSSProperties['cursor'];
+    /**
+     * Determines the type of user interaction that will cause the Popup to show/hide (note: the "click" option has been deprecated in favor of "press", which maintains the same behavior)
+     * @default "press"
+     */
+    trigger?: Trigger;
+    /**
+     * Determines the CSS width property to be applied to the Popup
+     * @default "auto"
+     * @deprecated width has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    width?: CSSProperties['width'];
+} & Pick<AriaProperties, 'ariaDescription' | 'ariaLabel'>;
+declare type Position = {
+    bottom?: CSSProperties['bottom'];
+    left?: CSSProperties['left'];
+    right?: CSSProperties['right'];
+    top?: CSSProperties['top'];
+};
+
+declare const Popup: WjecOneComponent<PopupProps$2>;
+
+/** @jsx jsx */
+
+declare type PopupProps$1 = React__default.ComponentProps<typeof Popup>;
+declare type Props$y = {
+    open?: PopupProps$1['open'];
+    position?: PopupProps$1['position'];
+    positionType?: PopupProps$1['positionType'];
+    toggle?: PopupProps$1['toggle'];
+} & Pick<AriaProperties, 'ariaDescription' | 'ariaLabel'>;
+declare const ContextHelp: WjecOneComponent<Props$y>;
+
+/** @jsx jsx */
+
+declare type PopupProps = React__default.ComponentProps<typeof Popup>;
+declare type ContextMenuOption = {
+    additionalInfo?: string | React__default.ReactElement;
+    icon?: (props: SVGProps<SVGSVGElement>) => SVGComponent;
+    label: FormattedString | React__default.ReactElement;
+    onClick?: () => void;
+};
+declare type ContextMenuSection = {
+    sectionTitle?: string;
+    sectionOptions: ContextMenuOption[];
+};
+declare type Props$x = {
+    description?: string;
+    onHide?: PopupProps['onHide'];
+    onShow?: PopupProps['onShow'];
+    open?: PopupProps['open'];
+    options: ContextMenuOption[] | ContextMenuSection[];
+    position?: PopupProps['position'];
+    positionType?: PopupProps['positionType'];
+    title?: string;
+    toggle?: PopupProps['toggle'];
+};
+declare const ContextMenu: WjecOneComponent<Props$x>;
+
+/** @jsx jsx */
+
+declare type Props$w<T> = {
+    gap?: GapProperty<any>;
+    items: T[];
+    onDrop?: (items: T[]) => void;
+    template?: FC<{
+        item: T;
+        Handle: FC<{
+            position?: {
+                bottom?: BottomProperty<any>;
+                left?: LeftProperty<any>;
+                right?: RightProperty<any>;
+                top?: TopProperty<any>;
+            };
+            positionType?: 'absolute' | 'relative';
+        }>;
+        index: number;
+        sortedItems: T[];
+    }>;
+};
+declare const DragAndDropList: <T extends unknown>({ gap, id, items, onDrop, template }: WjecOneComponentProps<Props$w<T>>) => JSX.Element;
+
+declare type Props$v = {
+    color?: ColorProperty;
+};
+declare const Emphasis: WjecOneComponent<Props$v>;
+
+declare type InputProps$1 = {
+    /**
+     * Determines whether the browser should provide autocomplete suggestions for this field
+     */
+    autoComplete?: InputHTMLAttributes<HTMLInputElement>['autoComplete'];
+    /**
+     * The text that will be displayed beneath the Input as a description/hint
+     */
+    description?: FormattedString;
+    /**
+     * Determines whether the Input field is subject to user interaction
+     */
+    disabled?: InputHTMLAttributes<HTMLInputElement>['disabled'];
+    /**
+     * Determines which area of the relevant CSS grid template the components are assigned to
+     * @deprecated gridArea has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    gridArea?: string;
+    /**
+     * An SVG component that will be rendered to the left of the Input's content. Usually used to denote the purpose of the input field (for example, an envelope icon for "email address")
+     */
+    icon?: (props: SVGProps<SVGSVGElement>) => SVGComponent;
+    /**
+     * A hint at the type of data expected, so that certain browsers/devices can display the relevant virtual keyboard
+     */
+    inputMode?: InputHTMLAttributes<HTMLInputElement>['inputMode'];
+    /**
+     * Determines whether the Input should be rendered in an error state
+     * @deprecated This prop has been deprecated due to the introduction of the new `status` prop, and is equivalent to `status='error'`
+     */
+    invalid?: boolean;
+    /**
+     * The text that will be displayed as the Input's label
+     */
+    label?: FormattedString;
+    /**
+     * Determines the maximum number of characters permitted for the Input's value
+     */
+    maxCharacters?: InputHTMLAttributes<HTMLInputElement>['maxLength'];
+    /**
+     * The string that will be assigned to the underlying HTML input element's "name" attribute
+     */
+    name?: InputHTMLAttributes<HTMLInputElement>['name'];
+    /**
+     * A handler that will be invoked if the Input loses focus. Provides a reference to the new focus target as the only argument
+     * @param focusTarget The HTML element to which focused has moved
+     * @returns void
+     */
+    onBlur?: (focusTarget: HTMLElement) => void;
+    /**
+     * A handler that will be invoked each time the content of the Input is changed. Provides the latest value as the only argument
+     * @param value The updated value of the Input
+     * @returns void
+     */
+    onChange?: (value: string) => void;
+    /**
+     * A handler that will be invoked if the Input receives focus
+     * @returns void
+     */
+    onFocus?: () => void;
+    /**
+     * A handler that will be invoked when a selection is chosen from the provided `suggestions` list. Provides the select value as the only argument
+     * @param value A string equal to the value that was selected
+     * @returns void
+     * @deprecated This prop has been deprecated because its functionality relies on non-standard implementation and will no longer be invoked. The previous behavior can be replicated by manually matching the `onChange()` value against the provided `suggestions` in the parent component
+     */
+    onPickSuggestion?: (value: string) => void;
+    /**
+     * The text that will be displayed as the Input's placeholder when no value is present
+     */
+    placeholder?: InputHTMLAttributes<HTMLInputElement>['placeholder'];
+    /**
+     * Determines whether the Input should be rendered in a readonly state
+     */
+    readonly?: InputHTMLAttributes<HTMLInputElement>['readOnly'];
+    /**
+     * Determines whether the Input is a required field
+     */
+    required?: InputHTMLAttributes<HTMLInputElement>['required'];
+    /**
+     * Determines the state in which the Input should be rendered
+     */
+    status?: 'error' | 'success' | 'warning';
+    /**
+     * An icon that will be rendered to the right of the Input's content. Usually used to denote the status of the input field (will default to the matching icon as determined by `status`, but can be overridden)
+     * @default status='error': ErrorIcon | status='success': SuccessIcon | status='warning': WarningIcon
+     */
+    statusIcon?: (props: SVGProps<SVGSVGElement>) => SVGComponent;
+    /**
+     * Determines whether the `statusIcon` is a further representation of the `status`, or whether it's being used for another purpose
+     * @default "status"
+     */
+    statusIconBehavior?: 'custom' | 'status';
+    /**
+     * The text that, if provided, will be displayed beneath the Input, relating to the `status`
+     */
+    statusMessage?: FormattedString;
+    /**
+     * A list of autocomplete suggestions that will be provided when the user interacts with the Input
+     */
+    suggestions?: string[];
+    /**
+     * The text that will be displayed if the Input does not satisfy the requirements determined by `required` and/or `validationPattern`
+     * @deprecated This prop has been deprecated due to the introduction of the new `statusMessage` prop, which functions similarly but is more semantically related to the associated `status` prop
+     */
+    validationMessage?: string;
+    /**
+     * A string containing a regular expression pattern that will be used to determine the validity of the Input
+     * @deprecated This prop has been deprecated due to the introduction of the new `status` prop. Validation should now be performed by the parent component, and the appropriate `status` and `statusMessage` values should be explicitly provided
+     */
+    validationPattern?: string;
+    /**
+     * A string that will be used as the value of the Input
+     * @default ""
+     */
+    value?: string;
+    /**
+     * A CSS width property that will be used to determine the horizontal dimensions of the Input
+     */
+    width?: CSSProperties['width'];
+} & Pick<AriaProperties, 'ariaLabel'>;
+
+declare const Input: WjecOneComponent<InputProps$1>;
+
+/** @jsx jsx */
+
+/**
+ * TODO list
+ * > Keyboard navigation (incl. close on tab out of expanded list)
+ */
+declare type InputProps = React__default.ComponentProps<typeof Input>;
+declare type Props$u<T> = {
+    clearButtonBehaviour?: 'clear' | 'clearAndClose' | 'close';
+    expanded?: boolean;
+    filter?: boolean;
+    floatingList?: boolean;
+    floatingListPosition?: {
+        bottom?: number;
+        left?: number;
+        right?: number;
+        top?: number;
+    };
+    icon?: InputProps['icon'];
+    label?: InputProps['label'];
+    loading?: boolean;
+    maxHeight?: number;
+    noMatchesMessage?: FormattedString;
+    onChange?: InputProps['onChange'];
+    onFilter?: (filteredOptions: T[]) => void;
+    optionKeyExtractor?: KeyExtractor<T>;
+    optionTemplate?: FC<{
+        option: T;
+        index: number;
+        filteredOptions: T[];
+    }>;
+    options: T[];
+    placeholder?: InputProps['placeholder'];
+    value?: InputProps['value'];
+} & Pick<AriaProperties, 'ariaExpanded' | 'ariaLabel' | 'ariaMultiselectable' | 'ariaPosInSet' | 'ariaSetSize'>;
+declare const FilterList: <T extends unknown>({ ariaLabel, ariaMultiselectable, ariaPosInSet, ariaSetSize, clearButtonBehaviour, expanded, filter, floatingList, floatingListPosition, icon, id, label, loading, maxHeight, noMatchesMessage, onChange, onFilter, optionKeyExtractor, optionTemplate, options, placeholder, value }: WjecOneComponentProps<Props$u<T>>) => JSX.Element;
+
+/** @jsx jsx */
+
+declare type ContextMenuProps$1 = React__default.ComponentProps<typeof ContextMenu>;
+declare type Props$t = {
+    clearButton?: false | string;
+    clearId?: string;
+    onClear?: () => void;
+    onSubmit?: () => void;
+    otherActions?: ContextMenuProps$1['options'];
+    submitButton?: false | string;
+    submitId?: string;
+    width?: WidthProperty<any>;
+} & Pick<AriaProperties, 'ariaDescription' | 'ariaLabel'>;
+declare const Form: WjecOneComponent<Props$t>;
+
+/** @jsx jsx */
+
+declare type Props$s = {
+    ariaLabel?: AriaProperties;
+    /**
+     * Determines whether the CheckBox is rendered in a checked state
+     * @default false
+     */
+    checked?: boolean;
+    /** Description for the checkbox */
+    description?: FormattedString;
+    /** Determines whether the CheckBox is subject to user interaction */
+    disabled?: boolean;
+    /**
+     * Determines which area of the relevant CSS grid template the CheckBox is assigned to
+     * @deprecated gridArea has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    gridArea?: string;
+    /** Determines whether the CheckBox should be visually highlighted
+     * @deprecated highlighted This prop has been deprecated because highlighting an checkbox component with a border color does not fit with the latest WJEC One design. Please use an alternative approach or CSS override
+     */
+    highlighted?: boolean;
+    /**
+   * An SVG component that will be rendered to the left of the Checkbox's content. Usually used to denote the purpose of the input field (for example, an envelope icon for "email address")
+   */
+    icon?: (props: SVGProps<SVGSVGElement>) => SVGComponent;
+    /** The identifier that will be pass through to the underlying HTML element */
+    id?: string;
+    /** Text that will be displayed as the CheckBox's label (Note: a more complex label can be achieved by instead providing the label as the CheckBox's children) */
+    label?: FormattedString;
+    /**
+     * Determines whether the label is allowed to wrap, or if it will be truncated instead
+     * @default "wrap"
+     */
+    labelOverflow?: 'ellipsis' | 'wrap';
+    /** Determines whether the CheckBox should render a loading animation to indicate activity */
+    loading?: boolean;
+    /** A handler that will be called when the checked state of the CheckBox is changed */
+    onChange?: (checked: boolean) => void;
+    /**
+       * Determines whether the Checkbox component is rendered as a visual representation instead of a form component
+       * @default false
+       * @deprecated This prop has been deprecated because the underlying HTML element does not support a "readonly" attribute, and therefore behavior cannot be guaranteed. An alternative such as `<Input readonly value='...' />` can be used
+       */
+    readonly?: boolean;
+    /**
+     * Determines the state in which the Input should be rendered
+     */
+    status?: 'error' | 'success' | 'warning';
+    /**
+     * The text that, if provided, will be displayed beneath the Checkbox, relating to the `status`
+     */
+    statusMessage?: string;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const CheckBox: WjecOneComponent<Props$s>;
+
+interface BaseProps {
+    date?: Date;
+    disabled?: boolean;
+    label?: FormattedString;
+    maxDate?: Date;
+    maxTime?: string;
+    minDate?: Date;
+    minTime?: string;
+    onChangeDate?: (date: Date) => void;
+    onChangeTime?: (time: string) => void;
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    time?: string;
+    type?: 'date' | 'dateTime' | 'time';
+    validationMessage?: string;
+    width?: CSSProperties['width'];
+}
+interface DateProps extends Omit<BaseProps, 'maxTime' | 'minTime' | 'onChangeTime' | 'time'> {
+    type?: 'date';
+}
+interface DateTimeProps extends BaseProps {
+    type?: 'dateTime';
+}
+interface TimeProps extends Omit<BaseProps, 'date' | 'maxDate' | 'minDate' | 'onChangeDate'> {
+    type?: 'time';
+}
+declare type Props$r = DateProps | DateTimeProps | TimeProps;
+declare const DateTimePicker: WjecOneComponent<Props$r>;
+
+/** @jsx jsx */
+
+declare type Props$q = React__default.ComponentProps<typeof Input>;
+declare const Email: WjecOneComponent<Props$q>;
+
+declare type Props$p = {
+    files?: File[];
+    height?: HeightProperty<any>;
+    max?: number;
+    multiple?: boolean;
+    onError?: (errors: Array<{
+        code: string;
+        details?: {
+            [key: string]: any;
+        };
+    }>) => void;
+    onSelect?: (files: File[]) => void;
+    placeholderDescription?: string;
+    placeholderTitle?: string;
+    validExtensions?: string[];
+    validTypes?: string[];
+    width?: WidthProperty<any>;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const FileInput: WjecOneComponent<Props$p>;
+
+declare type PasswordProps = {
+    /**
+     * The text that will be displayed beneath the Password field as a description/hint
+     */
+    description?: FormattedString;
+    /**
+     * Determines whether the password field is subject to user input
+     */
+    disabled?: boolean;
+    /**
+     * Determines which area of the relevant CSS grid template the Password is assigned to
+     * @deprecated gridArea has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    gridArea?: string;
+    /**
+     * Determines the border color of the Password field when `highlighted={true}`
+     * @deprecated This prop has been deprecated due to its association with the deprecated `highlighted` prop
+     */
+    highlightColor?: CSSProperties['color'];
+    /**
+     * Determines whether the Password component should be rendered with a different border color in order to draw attention to the field
+     * @deprecated This prop has been deprecated because highlighting an input component with a border color does not fit with the latest WJEC One design. Please use an alternative approach or CSS override
+     */
+    highlighted?: boolean;
+    /**
+     * The text that will be displayed as the Password field's label
+     */
+    label?: FormattedString;
+    /**
+     * The string that will be assigned to the underlying HTML input element's "name" attribute
+     */
+    name?: string;
+    /**
+     * A handler that will be invoked each time the content of the Password field is changed. Provides the latest value as the only argument
+     * @param password The updated value of the Password field
+     * @returns void
+     */
+    onChange?: (password: string) => void;
+    /**
+     * A handler that will be invoked each time the revealed state of the password is toggled. Provides a boolean value to indicate whether the password is currently revealed as the only argument
+     * @param isRevealed A boolean value indicating whether the password is currently revealed
+     * @returns void
+     */
+    onToggleRevealPassword?: (isRevealed: boolean) => void;
+    /**
+     * The text that will be displayed as the Password field's placeholder when no value is present
+     */
+    placeholder?: string;
+    /**
+     * Determines whether the value of the Password field should be visible
+     * @default false
+     */
+    revealPassword?: boolean;
+    /**
+     * Determines whether the value of the Password field should be visible
+     * @default false
+     * @deprecated This prop has been replaced with the new `revealPassword` prop, which has identical functionality but more clearly represents its intent
+     */
+    show?: boolean;
+    /**
+     * Determines whether the lock icon located on the left-hand side of the Password field should be visible
+     * @default true
+     */
+    showIcon?: boolean;
+    /**
+     * Determines the state in which the Password field should be rendered
+     */
+    status?: 'error' | 'success' | 'warning';
+    /**
+     * The text that, if provided, will be displayed beneath the Password field, relating to the `status`
+     */
+    statusMessage?: FormattedString;
+    /**
+     * A string that will be used as the value of the Password field
+     */
+    value?: string;
+} & Pick<AriaProperties, 'ariaLabel'>;
+
+declare const Password: WjecOneComponent<PasswordProps>;
+
+declare type Props$o<T> = {
+    /**
+     * The text that will be displayed beneath the Radiogroup as a description/hint
+    */
+    description?: string;
+    /** Determines whether the RadioGroup is subject to user interaction */
+    disabled?: boolean;
+    /**
+     * Determines which area of the relevant CSS grid template the RadioGroup is assigned to
+     * @deprecated gridArea has been deprecated because WJEC One components are intended to be layout agnostic
+    */
+    gridArea?: string;
+    /** A function that will be used to return a unique key for each item; required if data contains non-primitive entries */
+    keyExtractor?: KeyExtractor<T>;
+    /** Determines whether the RadioGroup option should be visually highlighted
+     * @deprecated highlightedOption This prop has been deprecated because highlighting an option within a RadioGroup component with a border color does not fit with the latest WJEC One design. Please use an alternative approach or CSS override
+    */
+    highlightedOption?: T;
+    /** Text that will be displayed as the RadioGroup's label */
+    label?: FormattedString;
+    /** A function that should be used to return a display value for each option if the options prop contains non-primitive entries */
+    labelExtractor?: ContentExtractor<T>;
+    /**
+     * The string that will be assigned to the underlying HTML input element's "name" attribute
+    */
+    name?: string;
+    /**
+     * A handler that will be called when the RadioGroup component's selection is changed. Provides a reference to the selected item as the only argument
+     * @param option A reference to the selected item from the "options" list
+     * @returns void
+    */
+    onSelect?: (option: T) => void;
+    /** The array of options that will be used to populate the RadioGroup component. */
+    options: T[];
+    /** Defines the layout of the RadioGroup's options */
+    orientation?: 'horizontal' | 'vertical';
+    /** The entry from the options prop that should be the RadioGroup component's selected option */
+    selectedOption?: T;
+    /**
+     * Determines the state in which the Input should be rendered
+    */
+    status?: 'error' | 'success' | 'warning';
+    /**
+     * The text that, if provided, will be displayed beneath the RadioGroup, relating to the `status`
+    */
+    statusMessage?: string;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const RadioGroup: <T extends {}>({ ariaLabel, description, disabled, gridArea, keyExtractor, highlightedOption, id: idProp, label, labelExtractor, name, onSelect, options, orientation, selectedOption, status, statusMessage }: WjecOneComponentProps<Props$o<T>>) => JSX.Element;
+
+declare type OptionsComparator<T> = (optionA: T, optionB: T) => number;
+declare type OptionsGroup<T> = {
+    label: string;
+    options: T[];
+};
+declare type SelectProps<T> = {
+    /**
+     * Determines whether to display an empty option at the top of the options list
+     * @default false
+     */
+    blankOption?: boolean;
+    /**
+     * The text that will be displayed beneath the Password field as a description/hint
+     */
+    description?: FormattedString;
+    /**
+     * Determines whether the Select component is subject to user interaction
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Determines which area of the relevant CSS grid template the Select component is assigned to
+     * @deprecated gridArea has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    gridArea?: string;
+    /**
+     * Determines the color used to highlight the Select component if `highlighted="true"`
+     * @default ColorPalette.highlight
+     * @deprecated This prop has been deprecated due to its association with the deprecated `highlighted` prop
+     */
+    highlightColor?: ColorProperty;
+    /**
+     * Determines whether the Select component should be visually highlighted with a colored border
+     * @default false
+     * @deprecated This prop has been deprecated because highlighting an input component with a border color does not fit with the latest WJEC One design. Please use an alternative approach or CSS override
+     */
+    highlighted?: boolean;
+    /** Text that will be displayed as the Select component's label */
+    label?: FormattedString;
+    /**
+     * The string that will be assigned to the underlying HTML input element's "name" attribute
+     */
+    name?: string;
+    /**
+     * A handler that will be called when the Select component's selection is changed. Provides a reference to the selected item as the only argument
+     * @param option A reference to the selected item from the "options" list
+     * @returns void
+     */
+    onSelect?: (option: T) => void;
+    /** The array of options that will be used to populate the Select component. Optionally, groups can be specified by providing an object with strictly two properties: `label` for the group name, `options` for the list of options inside the group */
+    options: Array<T | OptionsGroup<T>>;
+    /**
+     * A comparator function to determine the sort order if `sortOptions="true"`
+     * @deprecated This prop has been deprecated because the component no longer provides sorting functionality. Sorting should be performed in the parent component, and the sorted list provided via the `options` prop
+     */
+    optionComparator?: OptionsComparator<T>;
+    /** A function that should be used to return a unique key for each option if the options prop contains non-primitive or duplicate entries */
+    optionKeyExtractor?: KeyExtractor<T>;
+    /** A function that should be used to return a display value for each option if the options prop contains non-primitive entries */
+    optionLabelExtractor?: ContentExtractor<T>;
+    /** A string that will be displayed by the Select component if no option is currently selected */
+    placeholder?: string;
+    /**
+     * Determines whether the Select component is rendered as a readonly string instead of a form component
+     * @default false
+     * @deprecated This prop has been deprecated because the underlying HTML element does not support a "readonly" attribute, and therefore behavior cannot be guaranteed. An alternative such as `<Input readonly value='...' />` can be used
+     */
+    readonly?: boolean;
+    /** The entry from the options prop that should be the Select component's selected option */
+    selectedOption?: T;
+    /**
+     * Determines whether the Select component should sort the list of options as determined by the optionComparator prop
+     * @deprecated This prop has been deprecated because the component no longer provides sorting functionality. Sorting should be performed in the parent component, and the sorted list provided via the `options` prop
+     */
+    sortOptions?: boolean;
+    /**
+     * Determines the state in which the Select should be rendered
+     */
+    status?: 'error' | 'success' | 'warning';
+    /**
+     * The text that, if provided, will be displayed beneath the Select relating to the `status`
+     */
+    statusMessage?: FormattedString;
+};
+
+declare const Select: <T extends unknown>(props: WjecOneComponentProps<SelectProps<T>>) => JSX.Element;
+
+/** @jsx jsx */
+
+declare type Props$n = {
+    disabled?: boolean;
+    /**
+     * Determines which area of the relevant CSS grid template the TextArea is assigned to
+     * @deprecated gridArea has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    gridArea?: string;
+    height?: HeightProperty<any>;
+    label?: FormattedString;
+    maxCharacters?: number;
+    maxHeight?: HeightProperty<any>;
+    maxWidth?: WidthProperty<any>;
+    onChange?: (inputValue: string) => void;
+    placeholder?: string;
+    readonly?: boolean;
+    resizable?: boolean;
+    showCount?: boolean;
+    value?: string;
+    width?: WidthProperty<any>;
+} & Pick<AriaProperties, 'ariaDescription' | 'ariaLabel'>;
+declare const TextArea: WjecOneComponent<Props$n>;
+
+declare type Props$m = {
+    /**
+     * Determines whether the Toggle is subject to user input
+     */
+    disabled?: boolean;
+    /**
+     * Determines which area of the relevant CSS grid template the Toggle is assigned to
+     * @deprecated gridArea has been deprecated because WJEC One components are intended to be layout agnostic
+     */
+    gridArea?: string;
+    /**
+     * The string that will be displayed as the Toggle's label
+     */
+    label?: FormattedString;
+    /**
+     * Indicates the value for the off state of the label
+     * @deprecated offLabel has been deprecated because it is not required by the latest design
+     */
+    offLabel?: string;
+    /**
+     * Determines whether the Toggle is rendered in an "on" state
+     */
+    on?: boolean;
+    /**
+     * A handler that is called whenever the Toggle's "on" state is changed. Provides a single argument representing the updated "on" state
+     * @param isOn boolean
+     * @returns void
+     */
+    onChange?: (isOn: boolean) => void;
+    /**
+     * Indicates the value for the on state of the label
+     * @deprecated onLabel has been deprecated in favor of the new "value" prop, because the latest design does not support the concept of on/off values
+     */
+    onLabel?: string;
+    /**
+     * The string that will be displayed to indicate the value of the Toggle's "on" state
+     */
+    value?: FormattedString;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const Toggle: WjecOneComponent<Props$m>;
+
+/** @jsx jsx */
+
+declare type SVGFC$1 = (props: SVGProps<SVGSVGElement>) => SVGComponent;
+declare type Props$l = {
+    copyrightMessage?: FormattedString;
+    logos?: SVGFC$1[];
+    maxWidth?: number;
+};
+declare const Footer: FC<Props$l>;
+
+/** @jsx jsx */
+
+declare type SVGFC = (props: SVGProps<SVGSVGElement>) => SVGComponent;
+declare type Props$k = {
+    logo?: SVGFC | {
+        eduqas: SVGFC;
+        wjec: SVGFC;
+    };
+    logoId?: string;
+    logoStyles?: {
+        height: string;
+        padding: string;
+    };
+    maxWidth?: number;
+    menus?: JSX.Element;
+    onClickPageIcon?: (event: MouseEvent<HTMLAnchorElement>) => void;
+    pageIcon?: SVGFC;
+    pageIconHref?: string;
+    pageTitle?: FormattedString;
+    showPageTitle?: boolean;
+};
+declare const Header: FC<Props$k>;
+
+/** @jsx jsx */
+
+declare type FooterProps = React__default.ComponentProps<typeof Footer>;
+declare type HeaderProps = React__default.ComponentProps<typeof Header>;
+declare type Props$j = {
+    footerProps?: Partial<FooterProps>;
+    headerProps?: Partial<HeaderProps>;
+    maxWidth?: number;
+};
+declare const Page: FC<Props$j>;
+
+declare type Props$i = {
+    color?: ColorProperty;
+    progress?: number;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const LinearProgress: WjecOneComponent<Props$i>;
+
+declare type Props$h = {
+    breadcrumb?: boolean;
+    href: string;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const Link: WjecOneComponent<Props$h>;
+
+declare type IconsMap<L extends number | string | symbol> = {
+    [key in L]: ((props: SVGProps<SVGSVGElement>) => SVGComponent);
+};
+declare type Props$g<L extends number | string | symbol> = {
+    context: Context<[DestructurableRecord<LocalizationState<L>>, Dispatch<Action>]>;
+    icons?: IconsMap<L>;
+    keySuffix?: string;
+    open?: boolean;
+    selectLocaleAction: (locale: L) => AsyncAction;
+    showLocaleNameInList?: boolean;
+    showSelectedLocaleName?: boolean;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const LocalizationMenu: <L extends string | number | symbol>({ ariaLabel, context, icons, id, keySuffix, open, selectLocaleAction, showLocaleNameInList, showSelectedLocaleName }: WjecOneComponentProps<Props$g<L>>) => JSX.Element;
+
+declare type ButtonProps = React.ComponentProps<typeof Button>;
+declare type ContextMenuProps = React.ComponentProps<typeof ContextMenu>;
+declare type ModalProps = {
+    /**
+     * The label that will be displayed for the Modal's action button; providing a value of `false` will result in the action button being omitted
+     * @default "Confirm"
+     */
+    actionButton?: ButtonProps['label'] | false;
+    /** The identifier that will be passed through to the underlying HTML element of the action button */
+    actionButtonId?: ButtonProps['id'];
+    /** Determines whether the action button is subject to user interaction */
+    actionDisabled?: ButtonProps['disabled'];
+    /** Determines whether the action button should display a loading animation to indicate activity */
+    actionLoading?: ButtonProps['loading'];
+    /** Determines the progress % to be represented by the loading animation. If no value is provided, the loading animation will loop in an infinite, indeterminate state */
+    actionLoadingProgress?: ButtonProps['loadingProgress'];
+    /**
+     * Determines which button component is used to render the action button; `"negative"` will result in a DestructiveButton being used and `"positive"` will use a PrimaryButton
+     * @default "positive"
+     */
+    actionType?: 'negative' | 'positive';
+    /**
+     * Determines whether background scrolling should be disabled when the Modal is open
+     * @default true
+     */
+    blockScroll?: boolean;
+    /**
+     * The label that will be displayed for the Modal's cancel button; providing a value of `false` will result in the cancel button being omitted
+     * @default "Cancel"
+     */
+    cancelButton?: ButtonProps['label'] | false;
+    /** The identifier that will be passed through to the underlying HTML element of the cancel button */
+    cancelButtonId?: ButtonProps['id'];
+    /**
+     * Determines whether the Modal should close when the cancel button is pressed
+     * @default true
+     */
+    closeOnCancel?: boolean;
+    /**
+     * Determines whether the Modal should close when a click/touch is detected on the background overlay
+     * @default true
+     */
+    closeOnClickOutside?: boolean;
+    /** Description text that will be displayed between the Modal's header and content */
+    description?: FormattedString;
+    /**
+     * Determines whether the Modal should be rendered at a larger size that covers more of the display area
+     * @deprecated The fullscreen prop is no longer necessary since the Modal can be sized situationally using the maxHeight, maxWidth, minHeight and minWidth props
+     */
+    fullscreen?: boolean;
+    /**
+     * Determines the maximum permitted height of the Modal
+     * @default "90vh"
+     */
+    maxHeight?: CSSProperties['maxHeight'];
+    /**
+     * Determines the maximum permitted width of the Modal
+     * @default "60vw"
+     */
+    maxWidth?: CSSProperties['maxWidth'];
+    /**
+     * Determines the minimum permitted height of the Modal
+     * @default "200px"
+     */
+    minHeight?: CSSProperties['minHeight'];
+    /**
+     * Determines the minimum permitted width of the Modal
+     * @default "200px"
+     */
+    minWidth?: CSSProperties['minWidth'];
+    /**
+     * A callback that will be invoked when the Modal's action button is pressed
+     */
+    onAction?: () => void;
+    /**
+     * A callback that will be invoked when the Modal's cancel button is pressed
+     */
+    onCancel?: () => void;
+    /**
+     * A callback that will be invoked when the Modal is closed
+     */
+    onClose?: () => void;
+    /**
+     * A callback that will be invoked when the Modal is opened
+     */
+    onOpen?: () => void;
+    /** Determines whether the Modal should be displayed */
+    open?: boolean;
+    /**
+     * A set of custom controls that will be rendered in the Modal's footer. Can be either a React element or a configuration object for a ContextMenu
+     */
+    otherActions?: React.ReactElement | ContextMenuProps['options'];
+    /**
+     * The amount of padding around the edge of the Modal
+     * @default "30px"
+     */
+    padding?: CSSProperties['padding'];
+    /**
+     * Determines whether a close icon should be displayed in the top right corner of the Modal
+     * @default true
+     */
+    showCloseIcon?: boolean;
+    /**
+     * Determines whether the Modal will attempt to prevent changes to the content area's dimensions if dynamic content causes the scrollbar to show/hide
+     * @default true
+     */
+    stableScrollbar?: boolean;
+    /** The title that will be displayed in the Modal's header */
+    title?: FormattedString;
+} & Pick<AriaProperties, 'ariaDescription' | 'ariaLabel'>;
+
+declare const Modal: WjecOneComponent<ModalProps>;
+
+/** @jsx jsx */
+
+declare type NotificationProps$3 = {
+    actionColor?: ColorProperty;
+    actionIcon?: (props: SVGProps<SVGSVGElement>) => React__default.ReactElement;
+    actionLoading?: boolean;
+    actionLoadingProgress?: number;
+    actionText?: string;
+    actionTextColor?: ColorProperty;
+    autoClose?: number;
+    borderColor?: CSSProperties['color'];
+    icon?: 'none' | ((props: SVGProps<SVGSVGElement>) => React__default.ReactElement);
+    iconColor?: CSSProperties['color'];
+    maxWidth?: WidthProperty<any>;
+    message: FormattedString;
+    onActionClick?: () => void;
+    onClose?: () => void;
+    onOpen?: () => void;
+    open?: boolean;
+    position?: {
+        bottom?: BottomProperty<any>;
+        left?: LeftProperty<any>;
+        right?: RightProperty<any>;
+        top?: TopProperty<any>;
+    };
+    positionType?: PositionProperty;
+    showImmediately?: boolean;
+    title?: FormattedString;
+    titleColor?: CSSProperties['color'];
+};
+declare const Notification: WjecOneComponent<NotificationProps$3>;
+
+declare type NotificationProps$2 = React__default.ComponentProps<typeof Notification>;
+declare type Props$f = Omit<NotificationProps$2, 'actionColor' | 'actionTextColor' | 'borderColor' | 'icon' | 'titleColor'>;
+declare const ErrorNotification: FC<Props$f>;
+
+declare type NotificationProps$1 = React__default.ComponentProps<typeof Notification>;
+declare type Props$e = Omit<NotificationProps$1, 'actionColor' | 'actionTextColor' | 'borderColor' | 'icon' | 'iconColor' | 'titleColor'>;
+declare const InfoNotification: FC<Props$e>;
+
+declare type NotificationProps = React__default.ComponentProps<typeof Notification>;
+declare type Props$d = Omit<NotificationProps, 'actionColor' | 'actionTextColor' | 'borderColor' | 'icon' | 'iconColor' | 'titleColor'>;
+declare const SuccessNotification: FC<Props$d>;
+
+declare type Props$c = {
+    color?: ColorProperty;
+};
+declare const PageTitle: WjecOneComponent<Props$c>;
+
+declare type Props$b = {
+    compact?: boolean;
+    current?: number;
+    onSelect?: (page: number) => void;
+    total: number;
+} & Pick<AriaProperties, 'ariaCurrent' | 'ariaLabel'>;
+declare const Pagination: WjecOneComponent<Props$b>;
+
+declare type Props$a = {
+    color?: ColorProperty;
+};
+declare const Paragraph: WjecOneComponent<Props$a>;
+
+declare type Props$9 = {
+    height?: number;
+    onClose?: () => void;
+    onOpen?: (window: Window) => void;
+    open?: boolean;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+    title?: string;
+    width?: number;
+};
+declare const PopupWindow: WjecOneComponent<Props$9>;
+
+/** @jsx jsx */
+
+declare type Props$8 = {
+    footer?: FC;
+    header?: FC;
+    margin?: MarginProperty<number>;
+    onLayout?: () => void;
+    orientation?: 'landscape' | 'portrait';
+    verticalAlign?: 'baseline' | 'bottom' | 'middle' | 'sub' | 'super' | 'text-bottom' | 'text-top' | 'top';
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const PrintLayout: WjecOneComponent<Props$8>;
+
+declare type PopupWindowProps = React__default.ComponentProps<typeof PopupWindow>;
+declare type PrintLayoutProps = React__default.ComponentProps<typeof PrintLayout>;
+declare type Props$7 = PopupWindowProps & PrintLayoutProps & {
+    autoPrint?: boolean;
+    closeOnPrint?: boolean;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const PrintWindow: WjecOneComponent<Props$7>;
+
+/** @jsx jsx */
+
+declare type Props$6 = {
+    element?: keyof HTMLElementTagNameMap;
+    horizontal?: boolean;
+    styles?: Interpolation | ArrayInterpolation<any>;
+    vertical?: boolean;
+};
+declare const ScrollableContainer: FC<Props$6>;
+
+declare type Props$5 = {
+    color?: ColorProperty;
+};
+declare const SectionHeading: WjecOneComponent<Props$5>;
+
+declare type Props$4 = {
+    color?: ColorProperty;
+};
+declare const SectionTitle: WjecOneComponent<Props$4>;
+
+/** @jsx jsx */
+
+declare type ProfileAction = {
+    label: FormattedString;
+    icon?: (props: SVGProps<SVGSVGElement>) => SVGComponent;
+    onClick: () => void;
+};
+declare type Props$3 = {
+    allowForgotPassword?: boolean;
+    allowSignup?: boolean;
+    autocomplete?: boolean;
+    enforceFormCompletion?: boolean;
+    padding?: PaddingProperty<any>;
+    passwordValidator?: (passwordA: string, passwordB: string) => boolean;
+    profileActions?: ProfileAction[];
+    repeatNewPassword?: boolean;
+    type?: 'changePassword' | 'confirmResetPassword' | 'external' | 'forceChangePassword' | 'internal' | 'mfa' | 'requestResetPassword';
+    onCancel?: () => void;
+    onChangePassword?: (oldPassword: string, newPassword: string) => void;
+    onConfirmResetPassword?: (username: string, newPassword: string, code: string) => void;
+    onForceChangePassword?: (newPassword: string) => void;
+    onForgotPassword?: () => void;
+    onHaveResetCode?: () => void;
+    onRequestResetPassword?: (username: string) => void;
+    onSignin?: (username?: string, password?: string) => void;
+    onSignout?: () => void;
+    onSignup?: () => void;
+    onSubmitMfa?: (code: string) => void;
+    isSignedIn?: boolean;
+    loading?: boolean;
+    username?: string;
+    i18n?: {
+        cancel?: FormattedString;
+        code?: FormattedString;
+        forgotPassword?: FormattedString;
+        newPassword?: FormattedString;
+        password?: FormattedString;
+        repeatNewPassword?: FormattedString;
+        username?: FormattedString;
+        changePasswordPrompt?: FormattedString;
+        changePasswordSubmit?: FormattedString;
+        changePasswordTitle?: FormattedString;
+        changePasswordWarning?: FormattedString;
+        forceChangePasswordPrompt?: FormattedString;
+        forceChangePasswordTitle?: FormattedString;
+        mfaPrompt?: FormattedString;
+        mfaSubmit?: FormattedString;
+        mfaTitle?: FormattedString;
+        confirmResetPasswordPrompt?: FormattedString;
+        requestResetPasswordPrompt?: FormattedString;
+        resetPasswordHaveCode?: FormattedString;
+        resetPasswordSubmit?: FormattedString;
+        resetPasswordTitle?: FormattedString;
+        signin?: FormattedString;
+        signinPrompt?: FormattedString;
+        signout?: FormattedString;
+        signup?: FormattedString;
+        signupPrompt?: FormattedString;
+        welcomeMessage?: FormattedString;
+        welcomeMessageNotSignedIn?: FormattedString;
+        welcomeMessagePunctuation?: '' | '.' | ',' | '!' | '?' | ':';
+    };
+} & Pick<AriaProperties, 'ariaDescription' | 'ariaLabel'>;
+declare const SigninForm: WjecOneComponent<Props$3>;
+
+declare type SigninFormProps = React__default.ComponentProps<typeof SigninForm>;
+declare type Props$2 = SigninFormProps & {
+    onClose?: () => void;
+    onOpen?: () => void;
+    open?: boolean;
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const SigninMenu: WjecOneComponent<Props$2>;
+
+declare type Props$1 = {
+    color?: ColorProperty;
+};
+declare const SubParagraph: WjecOneComponent<Props$1>;
+
+declare const SubTitle: WjecOneComponent;
+
+declare type CellAlignment = 'center' | 'left' | 'right';
+declare type CellStyleExtractor<T> = (row: T, cellValue: string | number | JSX.Element, index: number) => Styles;
+declare type ColumnOptions = {
+    align?: 'center' | 'left' | 'right';
+};
+declare type ColumnWidth = 'max' | 'min' | CSSProperties['width'];
+declare type RowOptions<T> = {
+    group?: (row: T) => string;
+};
+declare type RowStyleExtractor<T> = (row: T, index: number) => Styles;
+declare type SortDirection = 'ascending' | 'descending';
+declare type TableColumnCellRenderer<T> = (row?: T) => JSX.Element;
+declare type TableColumnExtractor<T> = (row: T) => Array<TableColumnEntry<T>>;
+declare type TableColumnValueExtractor<T> = (row?: T) => FormattedString | number;
+interface TableColumnEntryTemplate<T> {
+    align?: CellAlignment;
+    headingStyle?: Styles;
+    onSort?: (direction: SortDirection) => void;
+    sortable?: boolean;
+    sortableValue?: KeyExtractor<T>;
+    sorted?: SortDirection | false;
+    style?: Styles | CellStyleExtractor<T>;
+    title: FormattedString;
+    width?: ColumnWidth;
+}
+interface TableColumnEntryWithComponent<T> extends TableColumnEntryTemplate<T> {
+    render: JSX.Element | TableColumnCellRenderer<T>;
+}
+interface TableColumnEntryWithKey<T> extends TableColumnEntryTemplate<T> {
+    key: keyof T;
+}
+interface TableColumnEntryWithValue<T> extends TableColumnEntryTemplate<T> {
+    value: FormattedString | number | TableColumnValueExtractor<T>;
+}
+declare type TableColumnEntry<T> = TableColumnEntryWithComponent<T> | TableColumnEntryWithKey<T> | TableColumnEntryWithValue<T>;
+declare type TableProps<T> = {
+    /** A React styles object or a serialized Emotion styles object (or a function that returns either of these) used to style each cell */
+    cellStyle?: Styles | CellStyleExtractor<T>;
+    /** A list of column configuration objects (or a function that returns the same) used to determine what is displayed by the Table */
+    columns: Array<TableColumnEntry<T>> | TableColumnExtractor<T>;
+    /** Options that will be applied to all columns in the Table (some options may be overridden on a per-column basis) */
+    columnOptions?: ColumnOptions;
+    /** The array of data that will be used to populate the table */
+    data: T[];
+    /** A function that will be used to return a unique key for each row; required if data contains non-primitive entries */
+    keyExtractor?: KeyExtractor<T>;
+    /**
+     * A handler that will be called when a row in the table is clicked
+     * @deprecated onClickRow has been deprecated in favor of the new onPressRow prop, which behaves similarly but with better accessibility support
+    */
+    onClickRow?: (row: T, index: number) => void;
+    /** A handler that will be called when a row in the table is pressed */
+    onPressRow?: (row: T, index: number) => void;
+    /** Determines whether the data arrives pre-sorted; if true, the Table will not attempt to sort the data itself even if sortable controls are presented */
+    preSorted?: boolean;
+    /** Options that will be applied to all rows in the Table */
+    rowOptions?: RowOptions<T>;
+    /** A React styles object or a serialized Emotion styles object (or a function that returns either of these) used to style each row */
+    rowStyle?: Styles | RowStyleExtractor<T>;
+    /** Determines whether the row for a particular data entry should be visually highlighted */
+    selectedRow?: T;
+    /** Determines whether the Table should present sortable controls (may be overridden on a per-column basis, and behavior may differ depending on the value of the preSorted prop) */
+    sortable?: boolean;
+};
+
+declare const Table: <T extends {}>({ cellStyle, columns, columnOptions, data, keyExtractor, id, onClickRow, onPressRow, preSorted, rowOptions, rowStyle, selectedRow, sortable }: WjecOneComponentProps<TableProps<T>>) => JSX.Element;
+
+declare type Props<T> = {
+    backgroundStyle?: 'filled' | 'transparent';
+    disabledTabs?: T[];
+    keyExtractor?: KeyExtractor<T>;
+    labelExtractor?: ContentExtractor<T>;
+    onSelect?: (tab: T) => void;
+    /**
+     * @deprecated The "scrollable" prop is now redundant, and the component
+     *             will behave as though scrollable={true} in all cases
+     */
+    scrollable?: boolean;
+    selectedTab?: T;
+    selectedTabColor?: ColorProperty;
+    tabs: T[];
+} & Pick<AriaProperties, 'ariaLabel'>;
+declare const Tabs: <T extends unknown>({ ariaLabel, backgroundStyle, disabledTabs, id, keyExtractor, labelExtractor, onSelect, scrollable, selectedTab, selectedTabColor, tabs }: WjecOneComponentProps<Props<T>>) => JSX.Element;
+
+export { Accordion, Breadcrumb, Button, Card, Carousel, CheckBox, CircularProgress, _default$2 as ColorPalette, _default$1 as ColorPaletteEduqas, ContextHelp, ContextMenu, DateTimePicker, DestructiveButton, DragAndDropList, Email, Emphasis, ErrorNotification, FileInput, FilterList, Footer, Form, Header, IconButton, InfoNotification, Input, LinearProgress, Link, LinkButton, LocalizationMenu, Modal, Notification, Page, PageTitle, Pagination, Paragraph, Password, Popup, PopupWindow, PrimaryButton, PrintLayout, PrintWindow, RadioGroup, ScrollableContainer, SecondaryButton, SectionHeading, SectionTitle, Select, SigninForm, SigninMenu, _default as StylePalette, SubParagraph, SubTitle, SuccessNotification, Table, Tabs, TextArea, Toggle };