baseui 0.0.0-next-c014e5b → 0.0.0-next-d5a66ca

package/README.md

@@ -58,11 +58,7 @@ export default function Hello () {
 }
 ```
 
-Both Base Web and Styletron come with [flow types](https://flow.org/) and [TypeScript](https://www.typescriptlang.org/index.html). All our components are typed and examples have Vanilla, Flow and TypeScript versions. For Styletron + TS, you need to add some additional packages:
-
-```bash
-yarn add @types/styletron-standard @types/styletron-react @types/styletron-engine-atomic
-```
+Both Base Web and Styletron come with [flow types](https://flow.org/) and [TypeScript](https://www.typescriptlang.org/index.html). All our components are typed and examples have Vanilla, Flow and TypeScript versions.
 
 ## Docs
 

package/a11y/a11y.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export default function A11y(props: {
+    children: React.ReactNode;
+}): JSX.Element;

package/a11y/index.d.ts

@@ -0,0 +1 @@
+export { default as Unstable_A11y } from './a11y';

package/a11y/types.d.ts

@@ -0,0 +1,5 @@
+import type { Result } from 'axe-core';
+export declare type ViolationProps = {
+    target: string;
+    violations: Result[];
+};

package/accordion/accordion.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { AccordionProps, AccordionState, StateChangeType } from './types';
+export default class Accordion extends React.Component<AccordionProps, AccordionState> {
+    static defaultProps: Partial<AccordionProps>;
+    state: {
+        expanded: React.Key[];
+    };
+    itemRefs: React.RefObject<HTMLDivElement>[];
+    onPanelChange(key: React.Key, onChange: (...args: any[]) => {}, ...args: Array<any>): void;
+    internalSetState(type: StateChangeType, changes: AccordionState): void;
+    handleKeyDown(e: KeyboardEvent): void;
+    getItems(): any;
+    render(): JSX.Element;
+}

package/accordion/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const STATE_CHANGE_TYPE: {
+    readonly expand: "expand";
+};

package/accordion/index.d.ts

@@ -0,0 +1,12 @@
+import type { SharedStylePropsArg } from './types';
+export { default as Accordion } from './accordion';
+export { default as Panel } from './panel';
+export { default as StatefulPanel } from './stateful-panel';
+export { default as StatefulPanelContainer } from './stateful-panel-container';
+export { default as StatelessAccordion } from './stateless-accordion';
+export { STATE_CHANGE_TYPE } from './constants';
+export { Root as StyledRoot, PanelContainer as StyledPanelContainer, Header as StyledHeader, Content as StyledContent, ContentAnimationContainer as StyledContentAnimationContainer, ToggleIcon as StyledToggleIcon, ToggleIconGroup as StyledToggleIconGroup, } from './styled-components';
+export * from './types';
+export type { AccordionLocale } from './locale';
+/** @deprecated use SharedStylePropsArg instead. To be removed in future versions.*/
+export declare type SharedProps = SharedStylePropsArg;

package/accordion/locale.d.ts

@@ -0,0 +1,9 @@
+export declare type AccordionLocale = {
+    collapse: string;
+    expand: string;
+};
+declare const locale: {
+    collapse: string;
+    expand: string;
+};
+export default locale;

package/accordion/panel.d.ts

@@ -0,0 +1,17 @@
+import * as React from 'react';
+declare const ForwardedPanel: React.ForwardRefExoticComponent<{
+    children: React.ReactNode;
+    disabled?: boolean;
+    'aria-controls'?: string;
+    key?: React.Key;
+    onChange?: import("./types").OnChangeHandler;
+    onClick?: (e: Event) => unknown;
+    onKeyDown?: (e: KeyboardEvent) => unknown;
+    overrides?: import("./types").PanelOverrides;
+    title?: React.ReactNode;
+    renderPanelContent?: boolean;
+    renderAll?: boolean;
+} & {
+    expanded?: boolean;
+} & React.RefAttributes<HTMLElement>>;
+export default ForwardedPanel;

package/accordion/stateful-panel-container.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import type { PanelState, StatefulPanelContainerProps, PanelStateReducer, StateChangeType, OnChangeHandler } from './types';
+declare class StatefulPanelContainer extends React.Component<StatefulPanelContainerProps, PanelState> {
+    static defaultProps: {
+        initialState: {
+            expanded: boolean;
+        };
+        stateReducer: PanelStateReducer;
+        onChange: () => void;
+    };
+    state: {
+        expanded: boolean;
+    };
+    onChange: OnChangeHandler;
+    internalSetState(type: StateChangeType, changes: PanelState): void;
+    render(): React.ReactNode;
+}
+export default StatefulPanelContainer;

package/accordion/stateful-panel.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { StatefulPanelProps } from './types';
+export default function StatefulPanel(props: StatefulPanelProps): JSX.Element;

package/accordion/stateless-accordion.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { StatelessAccordionProps } from './types';
+declare function StatelessAccordion({ accordion, children, disabled, expanded, onChange, overrides, renderAll, }: StatelessAccordionProps): JSX.Element;
+export default StatelessAccordion;

package/accordion/stateless-accordion.js

@@ -9,6 +9,8 @@ exports.default = void 0;
 
 var React = _interopRequireWildcard(require("react"));
 
+var _reactIs = require("react-is");
+
 var _overrides = require("../helpers/overrides");
 
 var _styledComponents = require("./styled-components");
@@ -67,9 +69,13 @@ function StatelessAccordion(_ref) {
   return /*#__PURE__*/React.createElement(Root, _extends({
     "data-baseweb": "accordion"
   }, rootProps), React.Children.map(children, function (child, index) {
-    var key = child.key || String(index);
-    return /*#__PURE__*/React.cloneElement(child, {
-      disabled: child.props.disabled || disabled,
+    var normalizedChild = (0, _reactIs.isElement)(child) || (0, _reactIs.isPortal)(child) ? child :
+    /*#__PURE__*/
+    // if primitive value - wrap it in a fragment
+    React.createElement(React.Fragment, null, child);
+    var key = normalizedChild.key || String(index);
+    return /*#__PURE__*/React.cloneElement(normalizedChild, {
+      disabled: normalizedChild.props.disabled || disabled,
       expanded: expanded.includes(key),
       key: key,
       onChange: // Don't bother constructing the wrapper function if no one is listening
@@ -97,7 +103,7 @@ function StatelessAccordion(_ref) {
           expanded: next
         });
       } : onChange,
-      overrides: child.props.overrides || PanelOverrides,
+      overrides: normalizedChild.props.overrides || PanelOverrides,
       renderAll: renderAll
     });
   }));

package/accordion/styled-components.d.ts

@@ -0,0 +1,13 @@
+import type { SharedStylePropsArg } from './types';
+/**
+ * Main component container element
+ */
+export declare const Root: import("styletron-react").StyletronComponent<"ul", {}>;
+export declare const PanelContainer: import("styletron-react").StyletronComponent<"li", SharedStylePropsArg>;
+export declare const Header: import("styletron-react").StyletronComponent<"div", SharedStylePropsArg>;
+export declare const ToggleIcon: import("styletron-react").StyletronComponent<"svg", SharedStylePropsArg>;
+export declare const ToggleIconGroup: import("styletron-react").StyletronComponent<"g", SharedStylePropsArg>;
+export declare const Content: import("styletron-react").StyletronComponent<"div", SharedStylePropsArg>;
+export declare const ContentAnimationContainer: import("styletron-react").StyletronComponent<"div", {
+    $height: string | number;
+} & SharedStylePropsArg>;

package/accordion/types.d.ts

@@ -0,0 +1,143 @@
+import * as React from 'react';
+import type { Override } from '../helpers/overrides';
+import { STATE_CHANGE_TYPE } from './constants';
+export declare type AccordionState = {
+    expanded: Array<React.Key>;
+};
+export declare type PanelState = {
+    expanded: boolean;
+};
+export declare type StateChangeType = keyof typeof STATE_CHANGE_TYPE;
+export declare type StateReducer = (stateChangeType: StateChangeType, nextState: AccordionState, currentState: AccordionState) => AccordionState;
+export declare type PanelStateReducer = (stateChangeType: StateChangeType, nextState: PanelState, currentState: PanelState) => PanelState;
+export declare type AccordionOverrides = {
+    Content?: Override;
+    ContentAnimationContainer?: Override;
+    Header?: Override;
+    PanelContainer?: Override;
+    Root?: Override;
+    ToggleIcon?: Override;
+    ToggleIconGroup?: Override;
+};
+export declare type PanelOverrides = {
+    PanelContainer?: Override;
+    Header?: Override;
+    ToggleIcon?: Override;
+    ToggleIconGroup?: Override;
+    Content?: Override;
+    ContentAnimationContainer?: Override;
+};
+export declare type OnChangeHandler = (a: {
+    expanded: boolean;
+}) => unknown;
+export declare type AccordionOnChangeHandler = (a: {
+    expanded: Array<React.Key>;
+}) => unknown;
+export declare type AccordionProps = {
+    /** Determines how many panels may be expanded at a time. If set to
+     * true it will collapse a current panel when a new panel is expanded.
+     * If set to false more than one panel may be expanded at a time. */
+    accordion?: boolean;
+    /** Accordion expandable items. See Panel API below for reference. */
+    children: React.ReactNode;
+    /** If set to true all its children panels will be disabled from toggling. */
+    disabled?: boolean;
+    initialState?: AccordionState;
+    /** Handler called each time a panel is toggled. expanded prop is an array
+     * of Panel keys that are currently expanded. */
+    onChange?: AccordionOnChangeHandler;
+    overrides?: AccordionOverrides;
+    /** Handler called each time the component state changes.
+     * Used to override default state-change functionality. */
+    stateReducer: StateReducer;
+    /**
+     * Allows users to render all child content whether a panel is expanded or not
+     * for SEO purposed
+     */
+    renderAll?: boolean;
+};
+export declare type StatelessAccordionOnChangeHandler = (a: {
+    expanded: Array<React.Key>;
+    key: React.Key;
+}) => unknown;
+export declare type StatelessAccordionProps = {
+    /** Determines how many panels may be expanded at a time. If set to
+     * true it will collapse a current panel when a new panel is expanded.
+     * If set to false more than one panel may be expanded at a time. */
+    accordion?: boolean;
+    /** Accordion expandable items. See Panel API below for reference. */
+    children: React.ReactNode;
+    /** If set to true all its children panels will be disabled from toggling. */
+    disabled?: boolean;
+    /** List of Panel keys which are expanded. */
+    expanded: Array<React.Key>;
+    /** Handler called each time a panel is toggled. */
+    onChange?: StatelessAccordionOnChangeHandler;
+    overrides?: AccordionOverrides & PanelOverrides;
+    /**
+     * Allows users to render all child content whether a panel is expanded or not
+     * for SEO purposed
+     */
+    renderPanelContent?: boolean;
+    /**
+     * Allows users to render all child content whether a panel is expanded or not
+     * for SEO purposed
+     */
+    renderAll?: boolean;
+};
+declare type SharedPanelProps = {
+    /** The content visible when Panel is expanded. */
+    children: React.ReactNode;
+    /** Defaults to the disabled value provided by the parent Accordion component. */
+    disabled?: boolean;
+    /** Id for a panel, when provided populates aria-controls
+     * attribute for panel button and content
+     * */
+    'aria-controls'?: string;
+    /** The key of a Panel. Used to maintain list of expanded panels.
+     * Must be unique across children of the Accordion. */
+    key?: React.Key;
+    /** Handler for individual Panel change events. */
+    onChange?: OnChangeHandler;
+    /** Handler for the Header's click events. */
+    onClick?: (e: Event) => unknown;
+    /** Handler for the Header's keyDown events. */
+    onKeyDown?: (e: KeyboardEvent) => unknown;
+    overrides?: PanelOverrides;
+    /** The title of an accordion panel. */
+    title?: React.ReactNode;
+    /**
+     * Allows users to render all child content whether a panel is expanded or not
+     * for SEO purposed
+     */
+    renderPanelContent?: boolean;
+    /**
+     * Allows users to render all child content whether a panel is expanded or not
+     * for SEO purposed
+     */
+    renderAll?: boolean;
+};
+export declare type PanelProps = SharedPanelProps & {
+    /** Defines if the panel is expanded. If set to true the panel is rendered expanded. */
+    expanded?: boolean;
+};
+declare type SharedStatefulPanelContainerProps = {
+    /** Initial state of a stateful panel component.
+     * The expanded prop indicates if the panel is initially expanded.
+     * If set to true the panel will be expanded initially */
+    initialState?: PanelState;
+    onChange?: OnChangeHandler;
+    stateReducer?: PanelStateReducer;
+};
+export declare type StatefulPanelContainerProps = SharedStatefulPanelContainerProps & {
+    children: (props: Omit<PanelProps, 'children'>) => React.ReactNode;
+};
+export declare type StatefulPanelProps = SharedStatefulPanelContainerProps & SharedPanelProps;
+export declare type SharedStylePropsArg = {
+    $color?: string;
+    $disabled: boolean | undefined | null;
+    $expanded?: boolean | null;
+    $size?: string | number;
+    $isFocusVisible: boolean;
+};
+export {};

package/app-nav-bar/app-nav-bar.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { AppNavBarProps } from './types';
+export default function AppNavBar(props: AppNavBarProps): JSX.Element;

package/app-nav-bar/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const POSITION: {
+    readonly horizontal: "horizontal";
+    readonly vertical: "vertical";
+};
+export declare const KIND: {
+    readonly primary: "primary";
+    readonly secondary: "secondary";
+};

package/app-nav-bar/index.d.ts

@@ -0,0 +1,14 @@
+import type { AppNavBarOverrides, NavItem, UserMenuProps, AppNavBarProps } from './types';
+export { default as AppNavBar } from './app-nav-bar';
+export { POSITION } from './constants';
+export * from './styled-components';
+export * from './types';
+export { setItemActive } from './utils';
+/** @deprecated use AppNavBarOverrides instead. To be removed in future versions.*/
+export declare type AppNavBarOverridesT = AppNavBarOverrides;
+/** @deprecated use NavItem instead. To be removed in future versions.*/
+export declare type NavItemT = NavItem;
+/** @deprecated use UserMenuProps instead. To be removed in future versions.*/
+export declare type UserMenuPropsT = UserMenuProps;
+/** @deprecated use AppNavBarProps instead. To be removed in future versions.*/
+export declare type AppNavBarPropsT = AppNavBarProps;

package/app-nav-bar/mobile-menu.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { AppNavBarProps } from './types';
+export default function MobileMenu(props: AppNavBarProps): JSX.Element;

package/app-nav-bar/styled-components.d.ts

@@ -0,0 +1,32 @@
+import { KIND } from './constants';
+export declare const StyledRoot: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledSubnavContainer: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledSpacing: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledAppName: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledSideMenuButton: import("styletron-react").StyletronComponent<"button", {
+    $isFocusVisible: boolean;
+}>;
+export declare const StyledPrimaryMenuContainer: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledMainMenuItem: import("styletron-react").StyletronComponent<"div", {
+    $active?: boolean;
+    $isFocusVisible: boolean;
+    $kind: (typeof KIND)[keyof typeof KIND];
+}>;
+export declare const StyledSecondaryMenuContainer: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledUserMenuButton: import("styletron-react").StyletronComponent<"button", {
+    $isFocusVisible: boolean;
+}>;
+export declare const StyledUserMenuProfileListItem: import("styletron-react").StyletronComponent<"li", {
+    $disabled?: boolean;
+    $isFocused?: boolean;
+    $isFocusVisible?: boolean;
+    $isHighlighted?: boolean;
+    $size?: "default" | "compact";
+} & {
+    item?: any;
+}>;
+export declare const StyledUserProfileTileContainer: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledUserProfilePictureContainer: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledUserProfileInfoContainer: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledDesktopMenuContainer: import("styletron-react").StyletronComponent<"div", {}>;
+export declare const StyledDesktopMenu: import("styletron-react").StyletronComponent<"div", {}>;

package/app-nav-bar/types.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { POSITION } from './constants';
+import type { Override } from '../helpers/overrides';
+export declare type AppNavBarOverrides = {
+    Root?: Override;
+    AppName?: Override;
+    DesktopMenu?: Override;
+    DesktopMenuContainer?: Override;
+    MainMenuItem?: Override;
+    PrimaryMenuContainer?: Override;
+    ProfileTileContainer?: Override;
+    SecondaryMenuContainer?: Override;
+    Spacing?: Override;
+    SubnavContainer?: Override;
+    UserMenuProfileListItem?: Override;
+    UserProfileInfoContainer?: Override;
+    UserProfilePictureContainer?: Override;
+    UserProfileTileContainer?: Override;
+    MobileDrawer?: Override;
+    MobileMenu?: Override;
+    SideMenuButton?: Override;
+    UserMenuButton?: Override;
+    UserMenu?: Override;
+};
+export declare type NavItem = {
+    active?: boolean;
+    icon?: React.ComponentType<any>;
+    info?: any;
+    label: string;
+    children?: NavItem[];
+    navExitIcon?: React.ComponentType<any>;
+    navPosition?: {
+        desktop?: typeof POSITION[keyof typeof POSITION];
+        mobile?: typeof POSITION[keyof typeof POSITION];
+    };
+};
+export declare type UserMenuProps = {
+    userItems?: NavItem[];
+    username?: string;
+    usernameSubtitle?: React.ReactNode;
+    userImgUrl?: string;
+    onUserItemSelect?: (a: NavItem) => unknown;
+};
+export declare type AppNavBarProps = {
+    isMainItemActive?: (a: NavItem) => boolean;
+    mainItems?: NavItem[];
+    mapItemToNode?: (a: NavItem) => React.ReactNode;
+    onMainItemSelect?: (a: NavItem) => unknown;
+    overrides?: AppNavBarOverrides;
+    title?: React.ReactNode;
+} & UserMenuProps;

package/app-nav-bar/user-menu.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import type { UserMenuProps, NavItem, AppNavBarOverrides } from './types';
+export default function UserMenuComponent(props: {
+    mapItemToNode: (a: NavItem) => React.ReactNode;
+    onItemSelect: (a: NavItem) => unknown;
+    overrides: AppNavBarOverrides;
+} & UserMenuProps): JSX.Element;

package/app-nav-bar/user-profile-tile.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { AppNavBarOverrides, UserMenuProps } from './types';
+export default function UserProfileTile(props: {
+    overrides: AppNavBarOverrides;
+} & UserMenuProps): JSX.Element;

package/app-nav-bar/utils.d.ts

@@ -0,0 +1,6 @@
+import type { NavItem } from './types';
+declare type GetUniqueIdentifier = (a: NavItem) => string | number;
+export declare function defaultMapItemToNode(item: NavItem): string;
+export declare function mapItemsActive(items: NavItem[], predicate: (a: NavItem) => boolean): NavItem[];
+export declare function setItemActive(items: NavItem[], item: NavItem, getUniqueIdentifier?: GetUniqueIdentifier): NavItem[];
+export {};

package/aspect-ratio-box/aspect-ratio-box-body.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { StyledBlockProps, BlockProps } from '../block';
+interface AspectRatioBoxBodyComponentType<D extends React.ElementType> {
+    <C extends React.ElementType = D>(props: BlockProps<C> & Omit<StyledBlockProps & React.ComponentProps<C>, keyof BlockProps>): JSX.Element;
+    displayName?: string;
+}
+export declare const AspectRatioBoxBody: AspectRatioBoxBodyComponentType<"div">;
+export default AspectRatioBoxBody;

package/aspect-ratio-box/aspect-ratio-box.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { type StyledBlockProps } from '../block';
+import type { AspectRatioBoxProps } from './types';
+interface AspectRatioCoxComponentType<D extends React.ElementType> {
+    <C extends React.ElementType = D>(props: AspectRatioBoxProps<C> & (React.ComponentProps<C> extends {
+        ref?: infer R;
+    } ? {
+        ref?: R;
+    } : {}) & Omit<StyledBlockProps & React.ComponentProps<C>, keyof AspectRatioBoxProps>): JSX.Element;
+    displayName?: string;
+}
+declare const AspectRatioBoxComponent: AspectRatioCoxComponentType<"div">;
+export default AspectRatioBoxComponent;

package/aspect-ratio-box/index.d.ts

@@ -0,0 +1,3 @@
+export { default as AspectRatioBox } from './aspect-ratio-box';
+export { default as AspectRatioBoxBody } from './aspect-ratio-box-body';
+export * from './types';

package/aspect-ratio-box/types.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import type { BlockProps } from '../block';
+export declare type AspectRatioBoxProps<T extends React.ElementType = React.ElementType> = {
+    /** Aspect ratio is width divided by height. */
+    readonly aspectRatio?: number;
+} & BlockProps<T>;

package/avatar/avatar.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { AvatarProps } from './types';
+export default function Avatar({ initials, name, overrides, size, src, }: AvatarProps): JSX.Element;

package/avatar/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Avatar } from './avatar';
+export { Avatar as StyledAvatar, Initials as StyledInitials, Root as StyledRoot, } from './styled-components';
+export * from './types';

package/avatar/styled-components.d.ts

@@ -0,0 +1,4 @@
+import type { AvatarStyleProps, RootStyleProps, InitialsStyleProps } from './types';
+export declare const Avatar: import("styletron-react").StyletronComponent<"img", AvatarStyleProps>;
+export declare const Initials: import("styletron-react").StyletronComponent<"div", InitialsStyleProps>;
+export declare const Root: import("styletron-react").StyletronComponent<"div", RootStyleProps>;

package/avatar/types.d.ts

@@ -0,0 +1,28 @@
+import type { Override } from '../helpers/overrides';
+export declare type InitialsStyleProps = {};
+export declare type AvatarStyleProps = {
+    $didImageFailToLoad?: boolean;
+    $imageLoaded?: boolean;
+    $size?: string;
+};
+export declare type RootStyleProps = {
+    $didImageFailToLoad: boolean;
+    $size?: string;
+};
+export declare type StyleProps = RootStyleProps;
+export declare type AvatarOverrides = {
+    Avatar?: Override;
+    Initials?: Override;
+    Root?: Override;
+};
+export declare type AvatarProps = {
+    /** Bypasses initial generation from provided name with this value. */
+    initials?: string;
+    /** Defines an alternative text description of the image. */
+    name?: string;
+    overrides?: AvatarOverrides;
+    /** Defines the width/height of the image. Accepts labels from theme.sizing, or passes value to height/width. */
+    size?: string;
+    /** Image to display. */
+    src?: string;
+};

package/badge/badge.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { BadgeProps } from './types';
+declare const Badge: ({ children, content, color, shape, placement, hierarchy, horizontalOffset, verticalOffset, hidden, overrides, }: BadgeProps) => JSX.Element;
+export default Badge;

package/badge/constants.d.ts

@@ -0,0 +1,36 @@
+export declare const HIERARCHY: Readonly<{
+    primary: "primary";
+    secondary: "secondary";
+}>;
+export declare const SHAPE: Readonly<{
+    pill: "pill";
+    rectangle: "rectangle";
+}>;
+export declare const COLOR: Readonly<{
+    accent: "accent";
+    primary: "primary";
+    positive: "positive";
+    negative: "negative";
+    warning: "warning";
+}>;
+export declare const PLACEMENT: Readonly<{
+    topLeft: "topLeft";
+    topRight: "topRight";
+    bottomRight: "bottomRight";
+    bottomLeft: "bottomLeft";
+    topLeftEdge: "topLeftEdge";
+    topEdge: "topEdge";
+    topRightEdge: "topRightEdge";
+    bottomRightEdge: "bottomRightEdge";
+    bottomEdge: "bottomEdge";
+    bottomLeftEdge: "bottomLeftEdge";
+    leftTopEdge: "leftTopEdge";
+    rightTopEdge: "rightTopEdge";
+    rightBottomEdge: "rightBottomEdge";
+    leftBottomEdge: "leftBottomEdge";
+}>;
+export declare const ROLE: Readonly<{
+    badge: "badge";
+    notificationCircle: "notificationCircle";
+    hintDot: "hintDot";
+}>;

package/badge/hint-dot.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { HintDotProps } from './types';
+declare const HintDot: ({ children, color, horizontalOffset: horizontalOffsetProp, verticalOffset: verticalOffsetProp, hidden, overrides, }: HintDotProps) => JSX.Element;
+export default HintDot;

package/badge/index.d.ts

@@ -0,0 +1,23 @@
+import type { Hierarchy, Shape, Color, Placement, BadgeOverrides, BadgeProps, NotificationCircleProps, HintDotProps } from './types';
+export { default as Badge } from './badge';
+export { default as NotificationCircle } from './notification-circle';
+export { default as HintDot } from './hint-dot';
+export { HIERARCHY, SHAPE, COLOR, PLACEMENT } from './constants';
+export * from './styled-components';
+export * from './types';
+/** @deprecated use Hierarchy instead. To be removed in future versions.*/
+export declare type HierarchyT = Hierarchy;
+/** @deprecated use Shape instead. To be removed in future versions.*/
+export declare type ShapeT = Shape;
+/** @deprecated use Color instead. To be removed in future versions.*/
+export declare type ColorT = Color;
+/** @deprecated use Placement instead. To be removed in future versions.*/
+export declare type PlacementT = Placement;
+/** @deprecated use BadgeOverrides instead. To be removed in future versions.*/
+export declare type BadgeOverridesT = BadgeOverrides;
+/** @deprecated use BadgeProps instead. To be removed in future versions.*/
+export declare type BadgePropsT = BadgeProps;
+/** @deprecated use NotificationCircleProps instead. To be removed in future versions.*/
+export declare type NotificationCirclePropsT = NotificationCircleProps;
+/** @deprecated use HintDotProps instead. To be removed in future versions.*/
+export declare type HintDotPropsT = HintDotProps;

package/badge/notification-circle.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { NotificationCircleProps } from './types';
+declare const NotificationCircle: ({ children, content: contentProp, color, placement, horizontalOffset, verticalOffset, hidden, overrides, }: NotificationCircleProps) => JSX.Element;
+export default NotificationCircle;