@strapi/design-system 1.18.0 → 2.0.0-beta.0

package/dist/ModalLayout/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ModalLayout';
+export * from './ModalHeader';
+export * from './ModalFooter';
+export * from './ModalBody';

package/dist/NumberInput/NumberInput.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { FieldInputProps, FieldProps, FieldLabelProps } from '../Field';
+export interface NumberInputProps extends Omit<FieldInputProps, 'id' | 'name' | 'onChange' | 'value'>, Pick<FieldProps, 'hint' | 'error' | 'id' | 'name'> {
+    label?: string;
+    labelAction?: FieldLabelProps['action'];
+    onValueChange: (value: number | undefined) => void;
+    locale?: string;
+    value?: number;
+    step?: number;
+}
+export declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/NumberInput/index.d.ts

@@ -0,0 +1 @@
+export * from './NumberInput';

package/dist/Pagination/Pagination.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export interface PaginationProps {
+    activePage: number;
+    children: React.ReactNode;
+    label?: string;
+    pageCount: number;
+}
+export declare const Pagination: ({ children, label, activePage, pageCount }: PaginationProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Pagination/PaginationContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface PaginationContextValue {
+    activePage: number;
+    pageCount: number;
+}
+export declare const PaginationContext: React.Context<PaginationContextValue>;
+export declare const usePagination: () => PaginationContextValue;

package/dist/Pagination/components.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { BaseLinkProps } from '../BaseLink';
+import { BoxProps } from '../Box';
+interface PaginationLinkProps extends BaseLinkProps {
+    active: boolean;
+}
+interface PaginationPageLinkProps extends PaginationLinkProps {
+    number: number;
+}
+interface DotsProps extends BoxProps {
+}
+export declare const PreviousLink: React.ForwardRefExoticComponent<PaginationLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export declare const NextLink: React.ForwardRefExoticComponent<PaginationLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export declare const PageLink: React.ForwardRefExoticComponent<PaginationPageLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export declare const Dots: ({ children, ...props }: DotsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Pagination/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Pagination';
+export * from './components';

package/dist/Popover/Popover.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import { Placement } from '@floating-ui/react-dom';
+import { BoxProps } from '../Box';
+import { DismissibleLayerProps } from '../DismissibleLayer';
+export declare const POPOVER_PLACEMENTS: readonly ["top", "top-start", "top-end", "right", "right-start", "right-end", "bottom", "bottom-start", "bottom-end", "left", "left-start", "left-end"];
+export interface ContentProps extends BoxProps<'div'>, Pick<DismissibleLayerProps, 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onDismiss' | 'onFocusOutside'> {
+    source: React.MutableRefObject<HTMLElement>;
+    placement?: Placement;
+    fullWidth?: boolean;
+    centered?: boolean;
+    spacing?: number;
+    hideAria?: boolean;
+}
+export declare const Content: React.ForwardRefExoticComponent<ContentProps & React.RefAttributes<HTMLDivElement>>;
+export interface ScrollingProps extends BoxProps<'div'> {
+    intersectionId?: string;
+    onReachEnd?: (entry: IntersectionObserverEntry) => void;
+}
+export declare const Scrolling: ({ children, intersectionId, onReachEnd, ...props }: ScrollingProps) => import("react/jsx-runtime").JSX.Element;
+export type PopoverProps = ScrollingProps & Pick<ContentProps, 'source' | 'spacing' | 'fullWidth' | 'placement' | 'centered' | 'onEscapeKeyDown' | 'onPointerDownOutside' | 'onDismiss'>;
+export declare const Popover: ({ children, source, spacing, fullWidth, placement, centered, onEscapeKeyDown, onPointerDownOutside, onDismiss, ...restProps }: PopoverProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Popover/index.d.ts

@@ -0,0 +1,3 @@
+export { Popover, POPOVER_PLACEMENTS } from './Popover';
+export type { PopoverProps } from './Popover';
+export * as PopoverPrimitives from './primitives';

package/dist/Popover/primitives.d.ts

@@ -0,0 +1,3 @@
+import { Content, Scrolling, ContentProps, ScrollingProps } from './Popover';
+export { Content, Scrolling };
+export type { ContentProps, ScrollingProps };

package/dist/Portal/Portal.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { BoxProps } from '../Box';
+export interface PortalProps extends BoxProps<'div'> {
+    container?: HTMLElement | null;
+}
+export declare const Portal: React.ForwardRefExoticComponent<PortalProps & React.RefAttributes<HTMLDivElement>>;

package/dist/Portal/index.d.ts

@@ -0,0 +1 @@
+export * from './Portal';

package/dist/ProgressBar/ProgressBar.d.ts

@@ -0,0 +1,11 @@
+import { BoxProps } from '../Box';
+type Enumerate<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc['length']]>;
+type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
+export interface ProgressBarProps extends Omit<BoxProps, 'background' | 'hasRadius' | 'height' | 'position' | 'width'> {
+    max?: IntRange<0, 101>;
+    min?: IntRange<0, 101>;
+    size?: 'S' | 'M';
+    value?: IntRange<0, 101>;
+}
+export declare const ProgressBar: ({ min, max, value, children, size, ...props }: ProgressBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ProgressBar/index.d.ts

@@ -0,0 +1 @@
+export * from './ProgressBar';

package/dist/Radio/Radio.d.ts

@@ -0,0 +1,5 @@
+import { BaseRadioProps } from '../BaseRadio/BaseRadio';
+export interface RadioProps extends BaseRadioProps {
+    children: React.ReactNode;
+}
+export declare const Radio: ({ children, ...props }: RadioProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Radio/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Radio';
+export { RadioGroup } from '../BaseRadio/RadioGroup';

package/dist/RawTable/RawCell.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { BoxProps } from '../Box';
+export interface RawTdProps extends BoxProps<'td'> {
+    'aria-colindex'?: number;
+    as?: 'td' | 'th';
+    children?: React.ReactNode;
+    coords?: {
+        col: number;
+        row: number;
+    };
+}
+export type RawThProps = Omit<RawTdProps, 'as'>;
+export declare const RawTh: (props: RawThProps) => import("react/jsx-runtime").JSX.Element;
+export declare const RawTd: ({ coords, as, ...props }: RawTdProps) => import("react/jsx-runtime").JSX.Element;

package/dist/RawTable/RawTable.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+export interface RawTableProps extends React.TableHTMLAttributes<HTMLTableElement> {
+    colCount: number;
+    initialCol?: number;
+    initialRow?: number;
+    jumpStep?: number;
+    rowCount: number;
+}
+export declare const RawTable: ({ colCount, rowCount, jumpStep, initialCol, initialRow, ...props }: {
+    [x: string]: any;
+    colCount: any;
+    rowCount: any;
+    jumpStep?: number | undefined;
+    initialCol?: number | undefined;
+    initialRow?: number | undefined;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/RawTable/RawTableContext.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export interface RawTableContextValue {
+    rowIndex: number;
+    colIndex: number;
+    setTableValues: ({ rowIndex, colIndex }: {
+        rowIndex: number;
+        colIndex: number;
+    }) => void;
+}
+export declare const RawTableContext: React.Context<RawTableContextValue>;
+export declare const useTable: () => RawTableContextValue;

package/dist/RawTable/RawTbody.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export interface RawTbodyProps extends React.TableHTMLAttributes<HTMLTableSectionElement> {
+    children: React.ReactNode;
+}
+export declare const RawTbody: ({ children, ...props }: RawTbodyProps) => import("react/jsx-runtime").JSX.Element;

package/dist/RawTable/RawThead.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+export interface RawTheadProps extends React.TableHTMLAttributes<HTMLTableSectionElement> {
+    children: React.ReactNode;
+}
+export declare const RawThead: ({ children, ...props }: RawTheadProps) => import("react/jsx-runtime").JSX.Element;

package/dist/RawTable/RawTr.d.ts

@@ -0,0 +1,5 @@
+import { BoxProps } from '../Box';
+export interface RawTrProps extends BoxProps<'tr'> {
+    'aria-rowindex'?: number;
+}
+export declare const RawTr: ({ children, ...props }: RawTrProps) => import("react/jsx-runtime").JSX.Element;

package/dist/RawTable/focusFocusable.d.ts

@@ -0,0 +1 @@
+export declare const focusFocusable: (node: any) => void;

package/dist/RawTable/index.d.ts

@@ -0,0 +1,5 @@
+export * from './RawTable';
+export * from './RawCell';
+export * from './RawThead';
+export * from './RawTbody';
+export * from './RawTr';

package/dist/Searchbar/SearchForm.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export type SearchFormProps = Omit<React.FormHTMLAttributes<HTMLFormElement>, 'role'>;
+export declare const SearchForm: (props: SearchFormProps) => JSX.Element;

package/dist/Searchbar/Searchbar.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { FieldInputProps, FieldProps } from '../Field';
+export interface SearchbarProps extends Omit<FieldInputProps, 'id' | 'name'>, Pick<FieldProps, 'id' | 'name'> {
+    name: string;
+    value?: string;
+    onClear: React.MouseEventHandler<any>;
+    clearLabel: string;
+}
+export declare const Searchbar: React.ForwardRefExoticComponent<SearchbarProps & React.RefAttributes<HTMLInputElement>>;

package/dist/Searchbar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Searchbar';
+export * from './SearchForm';

package/dist/Select/MultiSelect.d.ts

@@ -0,0 +1,40 @@
+import * as React from 'react';
+import * as SelectParts from './SelectParts';
+import { FieldLabelProps, FieldProps } from '../Field';
+type MultiSelectPropsWithoutLabel = Omit<SelectParts.MultiSelectProps, 'value' | 'multi'> & Pick<SelectParts.ContentProps, 'onCloseAutoFocus'> & Pick<SelectParts.TriggerProps, 'clearLabel' | 'onClear' | 'size' | 'startIcon'> & Pick<SelectParts.ValueProps, 'placeholder'> & Pick<FieldProps, 'hint' | 'id' | 'error'> & {
+    /**
+     * @default (value) => value.join(',')
+     */
+    customizeContent?(value?: string[]): string;
+    labelAction?: FieldLabelProps['action'];
+    onChange?: (value: string[]) => void;
+    onReachEnd?: (entry: IntersectionObserverEntry) => void;
+    /**
+     * @preserve
+     * @deprecated This prop is no longer required and will be removed in v2 of the DS.
+     * It has no effect on the component.
+     */
+    selectButtonTitle?: string;
+    value?: string[] | null;
+    withTags?: boolean;
+};
+export type MultiSelectProps = (MultiSelectPropsWithoutLabel & {
+    label: string;
+    'aria-label'?: never;
+}) | (MultiSelectPropsWithoutLabel & {
+    'aria-label': string;
+    label?: never;
+});
+export declare const MultiSelect: React.ForwardRefExoticComponent<MultiSelectProps & React.RefAttributes<HTMLDivElement>>;
+export interface MultiSelectOptionProps extends Omit<SelectParts.ItemProps, 'value'> {
+    startIcon?: React.ReactNode;
+    value: string | number;
+}
+export declare const MultiSelectOption: React.ForwardRefExoticComponent<MultiSelectOptionProps & React.RefAttributes<HTMLDivElement>>;
+export interface MultiSelectGroupProps extends Pick<MultiSelectOptionProps, 'startIcon'> {
+    children: React.ReactNode;
+    label: string;
+    values?: string[];
+}
+export declare const MultiSelectGroup: React.ForwardRefExoticComponent<MultiSelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/Select/MultiSelectNested.d.ts

@@ -0,0 +1,13 @@
+import { MultiSelectGroupProps, MultiSelectOptionProps, MultiSelectProps } from './MultiSelect';
+interface MulitSelectNestedOption extends Omit<MultiSelectOptionProps, 'children' | 'value'> {
+    value: string | number;
+    label: string;
+}
+interface MulitSelectNestedGroup extends Omit<MultiSelectGroupProps, 'children'> {
+    children: Array<MulitSelectNestedOption>;
+}
+export type MultiSelectNestedProps = MultiSelectProps & {
+    options: Array<MulitSelectNestedOption | MulitSelectNestedGroup>;
+};
+export declare const MultiSelectNested: ({ options, ...props }: MultiSelectNestedProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Select/SelectParts.d.ts

@@ -0,0 +1,67 @@
+import * as React from 'react';
+import { Select } from '@strapi/ui-primitives';
+import { BoxProps } from '../Box';
+import { TypographyProps } from '../Typography';
+interface TriggerProps extends BoxProps<'div'> {
+    /**
+     * @default "Clear"
+     */
+    clearLabel?: string;
+    disabled?: boolean;
+    hasError?: boolean;
+    onClear?: (e: React.MouseEvent<HTMLButtonElement | HTMLDivElement>) => void;
+    startIcon?: React.ReactElement;
+    /**
+     * @default "M"
+     */
+    size?: 'S' | 'M';
+}
+interface ValueProps extends Omit<TypographyProps, 'children' | 'placeholder'>, Pick<Select.SelectValueProps, 'placeholder' | 'children'> {
+    asChild?: boolean;
+}
+interface ItemProps extends Select.SelectItemProps {
+}
+declare const Root: {
+    (props: Select.SelectProps & {
+        __scopeSelect?: import("@radix-ui/react-context").Scope;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const Trigger: React.ForwardRefExoticComponent<TriggerProps & React.RefAttributes<HTMLDivElement>>;
+declare const Value: React.ForwardRefExoticComponent<ValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Portal: {
+    (props: Select.SelectPortalProps & {
+        __scopeSelect?: import("@radix-ui/react-context").Scope;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const Content: import("styled-components").StyledComponent<React.ForwardRefExoticComponent<Select.SelectContentImplProps & React.RefAttributes<HTMLDivElement>>, import("styled-components").DefaultTheme, {}, never>;
+declare const Viewport: import("styled-components").StyledComponent<React.ForwardRefExoticComponent<Pick<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: React.RefObject<HTMLDivElement> | ((instance: HTMLDivElement | null) => void) | null | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>>, import("styled-components").DefaultTheme, {}, never>;
+declare const Item: React.ForwardRefExoticComponent<ItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ItemIndicator: React.ForwardRefExoticComponent<Select.SelectItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ItemText: React.ForwardRefExoticComponent<Pick<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    ref?: React.RefObject<HTMLSpanElement> | ((instance: HTMLSpanElement | null) => void) | null | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLSpanElement> | "asChild"> & React.RefAttributes<HTMLSpanElement>>;
+declare const Group: React.ForwardRefExoticComponent<Pick<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    ref?: React.RefObject<HTMLDivElement> | ((instance: HTMLDivElement | null) => void) | null | undefined;
+} & {
+    asChild?: boolean | undefined;
+}, "key" | keyof React.HTMLAttributes<HTMLDivElement> | "asChild"> & React.RefAttributes<HTMLDivElement>>;
+type SelectProps = Select.SelectProps;
+type SingleSelectProps = Select.SingleSelectProps;
+type MultiSelectProps = Select.MultiSelectProps;
+type PortalProps = Select.SelectPortalProps;
+type ContentProps = Select.SelectContentProps;
+type ViewportProps = Select.SelectViewportProps;
+type ItemIndicatorProps = Select.SelectItemIndicatorProps;
+type ItemTextProps = Select.SelectItemTextProps;
+type GroupProps = Select.SelectGroupProps;
+type ValueRenderFn = Select.SelectValueRenderFn;
+export { Root, Trigger, Value, Portal, Content, Viewport, Item, ItemIndicator, ItemText, Group };
+export type { SingleSelectProps, MultiSelectProps, SelectProps, TriggerProps, ValueProps, ValueRenderFn, PortalProps, ContentProps, ViewportProps, ItemProps, ItemIndicatorProps, ItemTextProps, GroupProps, };

package/dist/Select/SingleSelect.d.ts

@@ -0,0 +1,41 @@
+import * as React from 'react';
+import * as SelectParts from './SelectParts';
+import { FieldLabelProps, FieldProps } from '../Field';
+type SingleSelectPropsWithoutLabel = Omit<SelectParts.SingleSelectProps, 'value'> & Pick<SelectParts.ContentProps, 'onCloseAutoFocus'> & Pick<SelectParts.TriggerProps, 'clearLabel' | 'onClear' | 'size' | 'startIcon'> & Pick<SelectParts.ValueProps, 'placeholder'> & Pick<FieldProps, 'error' | 'hint' | 'id'> & {
+    /**
+     * @default (value) => value.toString()
+     */
+    customizeContent?(value?: string | number): string;
+    labelAction?: FieldLabelProps['action'];
+    onChange?: (value: string | number) => void;
+    onReachEnd?: (entry: IntersectionObserverEntry) => void;
+    /**
+     * @preserve
+     * @deprecated This prop is no longer required and will be removed in v2 of the DS.
+     * It has no effect on the component.
+     */
+    selectButtonTitle?: string;
+    value?: string | number | null;
+};
+export type SingleSelectProps = (SingleSelectPropsWithoutLabel & {
+    label: string;
+    'aria-label'?: never;
+}) | (SingleSelectPropsWithoutLabel & {
+    'aria-label': string;
+    label?: never;
+});
+export type SingleSelectElement = SingleSelectInputElement;
+export declare const SingleSelect: React.ForwardRefExoticComponent<SingleSelectProps & React.RefAttributes<HTMLDivElement>>;
+export interface SingleSelectInputProps extends Omit<SingleSelectPropsWithoutLabel, 'labelAction' | 'hint' | 'id'> {
+    'aria-label'?: string;
+    id?: string;
+    label?: string;
+}
+export type SingleSelectInputElement = HTMLDivElement;
+export declare const SingleSelectInput: React.ForwardRefExoticComponent<SingleSelectInputProps & React.RefAttributes<HTMLDivElement>>;
+export interface SingleSelectOptionProps extends Omit<SelectParts.ItemProps, 'value'> {
+    startIcon?: React.ReactNode;
+    value: string | number;
+}
+export declare const SingleSelectOption: React.ForwardRefExoticComponent<SingleSelectOptionProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/Select/index.d.ts

@@ -0,0 +1,6 @@
+export { MultiSelectNested } from './MultiSelectNested';
+export type { MultiSelectNestedProps } from './MultiSelectNested';
+export { MultiSelect, MultiSelectGroup, MultiSelectOption } from './MultiSelect';
+export type { MultiSelectProps, MultiSelectGroupProps, MultiSelectOptionProps } from './MultiSelect';
+export { SingleSelect, SingleSelectOption } from './SingleSelect';
+export type { SingleSelectProps, SingleSelectOptionProps } from './SingleSelect';

package/dist/SimpleMenu/Menu.d.ts

@@ -0,0 +1,56 @@
+import * as React from 'react';
+import * as DropdownMenu from '@radix-ui/react-dropdown-menu';
+import { BaseLink } from '../BaseLink';
+import { BoxProps } from '../Box';
+import { ButtonProps } from '../Button';
+import { FlexProps } from '../Flex';
+import { LinkProps } from '../Link';
+import { POPOVER_PLACEMENTS } from '../Popover';
+import { TypographyProps } from '../Typography';
+interface RootProps extends DropdownMenu.DropdownMenuProps {
+}
+interface TriggerProps extends ButtonProps {
+}
+interface ContentProps extends FlexProps<'div'> {
+    intersectionId?: string;
+    popoverPlacement?: (typeof POPOVER_PLACEMENTS)[number];
+}
+interface ItemSharedProps extends Pick<DropdownMenu.MenuItemProps, 'disabled' | 'onSelect'> {
+    children?: React.ReactNode;
+    isExternal?: boolean;
+    isFocused?: boolean;
+}
+interface ItemExternalLinkProps extends ItemSharedProps, Omit<LinkProps, 'onSelect'> {
+    as?: never;
+    isLink?: false;
+    isExternal?: true;
+}
+type ItemInternalLinkProps<TComponent extends React.ComponentType = typeof BaseLink> = ItemSharedProps & React.ComponentPropsWithoutRef<TComponent> & {
+    as?: TComponent;
+    isLink?: true;
+    isExternal?: false;
+};
+interface ItemButtonProps extends ItemSharedProps, Omit<BoxProps<'button'>, 'onSelect'> {
+    as?: never;
+    isLink?: false;
+    isExternal?: false;
+}
+type ItemProps<TComponent extends React.ComponentType = typeof BaseLink> = ItemButtonProps | ItemInternalLinkProps<TComponent> | ItemExternalLinkProps;
+interface LabelProps extends TypographyProps {
+}
+interface SubRootProps extends DropdownMenu.DropdownMenuSubProps {
+}
+interface SubTriggerProps extends BoxProps<'button'> {
+}
+interface SubContentProps extends FlexProps<'div'> {
+}
+declare const Root: React.FC<DropdownMenu.DropdownMenuProps>;
+declare const Trigger: React.ForwardRefExoticComponent<TriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Content: React.ForwardRefExoticComponent<ContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const Item: ({ onSelect, disabled, ...props }: ItemProps) => import("react/jsx-runtime").JSX.Element;
+declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SubRoot: React.FC<DropdownMenu.DropdownMenuSubProps>;
+declare const SubTrigger: React.ForwardRefExoticComponent<SubTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SubContent: React.ForwardRefExoticComponent<SubContentProps & React.RefAttributes<HTMLDivElement>>;
+export { Root, Trigger, Content, Item, Label, SubRoot, SubTrigger, SubContent };
+export type { TriggerProps, ContentProps, ItemProps, RootProps, SubRootProps, SubTriggerProps, SubContentProps, LabelProps, };

package/dist/SimpleMenu/SimpleMenu.d.ts

@@ -0,0 +1,60 @@
+import * as React from 'react';
+import * as Menu from './Menu';
+interface SimpleMenuProps extends Omit<Menu.TriggerProps, 'children'>, Pick<Menu.ContentProps, 'popoverPlacement' | 'intersectionId'> {
+    children?: React.ReactNode;
+    label?: React.ReactNode;
+    onOpen?: () => void;
+    onClose?: () => void;
+    /**
+     * Callback function to be called when the popover reaches the end of the scrollable content
+     */
+    onReachEnd?: (entry: IntersectionObserverEntry) => void;
+}
+declare const SimpleMenu: ({ children, onOpen, onClose, popoverPlacement, onReachEnd, ...props }: SimpleMenuProps) => import("react/jsx-runtime").JSX.Element;
+declare const MenuItem: ({ onSelect, disabled, ...props }: Menu.ItemProps<React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & Pick<import("styled-components").CSSProperties, "cursor" | "display" | "overflow" | "pointerEvents" | "transform" | "position" | "textAlign" | "textTransform" | "zIndex" | "animation" | "transition"> & {
+    _hover?: ((theme: import("styled-components").DefaultTheme) => string) | undefined;
+    background?: import("../types").DefaultThemeOrCSSProp<"colors", "background">;
+    basis?: import("csstype").Property.FlexBasis<string | number> | undefined;
+    borderColor?: keyof import("../themes/colors").Colors | undefined;
+    color?: keyof import("../themes/colors").Colors | undefined;
+    flex?: import("csstype").Property.Flex<string | number> | undefined;
+    fontSize?: import("../types").DefaultThemeOrCSSProp<"fontSizes", "fontSize">;
+    grow?: import("csstype").Property.FlexGrow | undefined;
+    hasRadius?: boolean | undefined;
+    hiddenS?: boolean | undefined;
+    hiddenXS?: boolean | undefined;
+    padding?: import("../helpers/handleResponsiveValues").ResponsiveValue<"padding">;
+    paddingBottom?: import("../helpers/handleResponsiveValues").ResponsiveValue<"paddingBottom">;
+    paddingLeft?: import("../helpers/handleResponsiveValues").ResponsiveValue<"paddingLeft">;
+    paddingRight?: import("../helpers/handleResponsiveValues").ResponsiveValue<"paddingRight">;
+    paddingTop?: import("../helpers/handleResponsiveValues").ResponsiveValue<"paddingTop">;
+    marginLeft?: import("../helpers/handleResponsiveValues").ResponsiveValue<"marginLeft">;
+    marginBottom?: import("../helpers/handleResponsiveValues").ResponsiveValue<"marginBottom">;
+    marginRight?: import("../helpers/handleResponsiveValues").ResponsiveValue<"marginRight">;
+    marginTop?: import("../helpers/handleResponsiveValues").ResponsiveValue<"marginTop">;
+    shadow?: keyof import("../themes/colors").Shadows | undefined;
+    shrink?: import("csstype").Property.FlexShrink | undefined;
+    lineHeight?: import("../types").DefaultThemeOrCSSProp<"lineHeights", "lineHeight">;
+    width?: import("../types").DefaultThemeOrCSSProp<"spaces", "width">;
+    minWidth?: import("../types").DefaultThemeOrCSSProp<"spaces", "minWidth">;
+    maxWidth?: import("../types").DefaultThemeOrCSSProp<"spaces", "maxWidth">;
+    height?: import("../types").DefaultThemeOrCSSProp<"spaces", "height">;
+    minHeight?: import("../types").DefaultThemeOrCSSProp<"spaces", "minHeight">;
+    maxHeight?: import("../types").DefaultThemeOrCSSProp<"spaces", "maxHeight">;
+    top?: import("../types").DefaultThemeOrCSSProp<"spaces", "top">;
+    left?: import("../types").DefaultThemeOrCSSProp<"spaces", "left">;
+    bottom?: import("../types").DefaultThemeOrCSSProp<"spaces", "bottom">;
+    right?: import("../types").DefaultThemeOrCSSProp<"spaces", "right">;
+    borderRadius?: import("csstype").Property.BorderRadius<string | number> | undefined;
+    borderStyle?: import("csstype").Property.BorderStyle | undefined;
+    borderWidth?: import("csstype").Property.BorderWidth<string | number> | undefined;
+    children?: React.ReactNode;
+    as?: string | React.ComponentType<any> | undefined;
+    forwardedAs?: string | React.ComponentType<any> | undefined;
+} & {
+    disabled?: boolean | undefined;
+    isExternal?: boolean | undefined;
+} & React.RefAttributes<HTMLAnchorElement>>>) => import("react/jsx-runtime").JSX.Element;
+type MenuItemProps = Menu.ItemProps;
+export { SimpleMenu, MenuItem, Menu };
+export type { SimpleMenuProps, MenuItemProps };

package/dist/SimpleMenu/index.d.ts

@@ -0,0 +1 @@
+export * from './SimpleMenu';

package/dist/Status/Status.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { BoxProps } from '../Box';
+export type StatusVariant = 'alternative' | 'danger' | 'neutral' | 'primary' | 'secondary' | 'success' | 'warning';
+export type StatusSize = 'S' | 'M';
+export interface StatusProps extends BoxProps {
+    variant?: StatusVariant;
+    /**
+     * If `false`, the preceeding bullet of the status won't be displayed.
+     * This prop and the bullet will be removed in the next major version.
+     */
+    showBullet?: boolean;
+    size?: StatusSize;
+    children: React.ReactNode;
+}
+export declare const Status: ({ variant, showBullet, size, children, ...props }: StatusProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Status/index.d.ts

@@ -0,0 +1 @@
+export * from './Status';

package/dist/SubNav/SubNav.d.ts

@@ -0,0 +1,6 @@
+import { GridProps } from '../Grid';
+export declare const subNavWidth = "23.2rem";
+export interface SubNavProps extends GridProps {
+    ariaLabel: string;
+}
+export declare const SubNav: ({ ariaLabel, ...props }: SubNavProps) => import("react/jsx-runtime").JSX.Element;

package/dist/SubNav/SubNavHeader.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export interface SubNavHeaderProps {
+    as?: keyof JSX.IntrinsicElements;
+    id?: string;
+    label: string;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+    onClear?: React.MouseEventHandler<HTMLInputElement>;
+    onSubmit?: React.FormEventHandler<HTMLInputElement>;
+    searchLabel?: string;
+    searchable?: boolean;
+    value?: string;
+}
+export declare const SubNavHeader: ({ as, label, searchLabel, searchable, onChange, value, onClear, onSubmit, id, }: SubNavHeaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/SubNav/SubNavLink.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface SubNavLinkProps {
+    as?: React.ElementType;
+    children: React.ReactNode;
+    icon?: React.ReactElement;
+    isSubSectionChild?: boolean;
+    withBullet?: boolean;
+}
+export declare const SubNavLink: React.ForwardRefExoticComponent<SubNavLinkProps & React.RefAttributes<unknown>>;

package/dist/SubNav/SubNavLinkSection.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface SubNavLinkSectionProps {
+    children: React.ReactNode;
+    id?: string;
+    label: string;
+}
+export declare const SubNavLinkSection: ({ label, children, id }: SubNavLinkSectionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/SubNav/SubNavSection.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface SubNavSectionProps {
+    badgeLabel?: string;
+    children: React.ReactNode;
+    collapsable?: boolean;
+    id?: string;
+    label: string;
+}
+export declare const SubNavSection: ({ collapsable, label, badgeLabel, children, id }: SubNavSectionProps) => import("react/jsx-runtime").JSX.Element;

package/dist/SubNav/SubNavSectionLabel.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export interface SubNavSectionLabelProps {
+    ariaControls?: string;
+    ariaExpanded?: boolean;
+    collapsable?: boolean;
+    label: string;
+    onClick: React.MouseEventHandler<HTMLButtonElement> & React.MouseEventHandler<HTMLDivElement>;
+}
+export declare const SubNavSectionLabel: ({ collapsable, label, onClick, ariaExpanded, ariaControls, }: SubNavSectionLabelProps) => import("react/jsx-runtime").JSX.Element;

package/dist/SubNav/SubNavSections.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { FlexProps } from '../Flex';
+export interface SubNavSectionsProps extends FlexProps<'ol'> {
+    children: React.ReactNode;
+    spacing?: number;
+    horizontal?: boolean;
+}
+export declare const SubNavSections: ({ children, spacing, horizontal, ...props }: SubNavSectionsProps) => import("react/jsx-runtime").JSX.Element;