@peculiar/react-components 1.1.1 → 1.1.3

package/dist/types/Fab/fab.d.ts

@@ -1,23 +1,23 @@
 import * as React from 'react';
-import { OverridableComponent, OverrideProps } from '../OverridableComponent';
-import { ButtonBaseOwnProps } from '../ButtonBase';
+import { IOverridableComponent, TOverrideProps } from '../OverridableComponent';
+import { IButtonBaseOwnProps } from '../ButtonBase';
 /**
  * Types.
  */
-export interface FabOwnProps extends Omit<ButtonBaseOwnProps, 'size' | 'variant'> {
+export interface IFabOwnProps extends Omit<IButtonBaseOwnProps, 'size' | 'variant'> {
     /**
      * The variant to use.
      */
     variant?: ('contained' | 'outlined');
 }
-export interface FabTypeMap<P = {}, D extends React.ElementType = 'button'> {
-    props: P & FabOwnProps;
+export interface IFabTypeMap<P = object, D extends React.ElementType = 'button'> {
+    props: P & IFabOwnProps;
     defaultComponent: D;
 }
-export declare type FabProps<D extends React.ElementType = FabTypeMap['defaultComponent']> = OverrideProps<FabTypeMap<{}, D>, D> & {
+export type TFabProps<D extends React.ElementType = IFabTypeMap['defaultComponent']> = TOverrideProps<IFabTypeMap<object, D>, D> & {
     component?: D;
 };
 /**
  *
  */
-export declare const Fab: OverridableComponent<FabTypeMap<{}, "button">>;
+export declare const Fab: IOverridableComponent<IFabTypeMap<object, "button">>;

package/dist/types/Fab/index.d.ts

@@ -1,2 +1,2 @@
-export { Fab, } from './fab';
-export type { FabOwnProps, FabProps, } from './fab';
+export { Fab } from './fab';
+export type { IFabOwnProps, TFabProps, } from './fab';

package/dist/types/Fade/fade.d.ts

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import type { TransitionProps } from 'react-transition-group/Transition';
-export declare type BaseTransitionProps = Pick<TransitionProps<HTMLElement>, ('onEnter' | 'onEntered' | 'onEntering' | 'onExit' | 'onExited' | 'onExiting')>;
-declare type BaseProps = {
+export type TBaseTransitionProps = Pick<TransitionProps<HTMLElement>, ('onEnter' | 'onEntered' | 'onEntering' | 'onExit' | 'onExited' | 'onExiting')>;
+interface IBaseProps {
     /**
      * If `true`, the component will transition in.
      */
@@ -19,6 +19,6 @@ declare type BaseProps = {
      * Perform the enter transition when it first mounts if `in` is also `true`.
      */
     appear?: boolean;
-};
-export declare const Fade: React.ForwardRefExoticComponent<BaseProps & BaseTransitionProps & React.RefAttributes<any>>;
+}
+export declare const Fade: React.ForwardRefExoticComponent<IBaseProps & TBaseTransitionProps & React.RefAttributes<any>>;
 export {};

package/dist/types/Fade/index.d.ts

@@ -1,2 +1,2 @@
 export { Fade } from './fade';
-export type { BaseTransitionProps } from './fade';
+export type { TBaseTransitionProps } from './fade';

package/dist/types/Flex/flex.d.ts

@@ -1,23 +1,23 @@
 import * as React from 'react';
-import { OverridableComponent, OverrideProps } from '../OverridableComponent';
+import { IOverridableComponent, TOverrideProps } from '../OverridableComponent';
 /**
  * Types.
  */
-export interface FlexOwnProps {
+export interface IFlexOwnProps {
     /**
      * The content of the component.
      */
     children?: React.ReactNode;
     size?: ('auto' | 'grow');
 }
-export interface FlexTypeMap<P = {}, D extends React.ElementType = 'div'> {
-    props: P & FlexOwnProps;
+export interface IFlexTypeMap<P = object, D extends React.ElementType = 'div'> {
+    props: P & IFlexOwnProps;
     defaultComponent: D;
 }
-export declare type FlexProps<D extends React.ElementType = FlexTypeMap['defaultComponent']> = OverrideProps<FlexTypeMap<{}, D>, D> & {
+export type TFlexProps<D extends React.ElementType = IFlexTypeMap['defaultComponent']> = TOverrideProps<IFlexTypeMap<object, D>, D> & {
     component?: D;
 };
 /**
  *
  */
-export declare const Flex: OverridableComponent<FlexTypeMap<{}, "div">>;
+export declare const Flex: IOverridableComponent<IFlexTypeMap<object, "div">>;

package/dist/types/Flex/flex_container.d.ts

@@ -1,10 +1,10 @@
 import * as React from 'react';
 import type { Property } from 'csstype';
-import { OverridableComponent, OverrideProps } from '../OverridableComponent';
+import { IOverridableComponent, TOverrideProps } from '../OverridableComponent';
 /**
  * Types.
  */
-export interface FlexContainerOwnProps {
+export interface IFlexContainerOwnProps {
     /**
      * The content of the component.
      */
@@ -30,14 +30,14 @@ export interface FlexContainerOwnProps {
      */
     justify?: Property.JustifyContent;
 }
-export interface FlexContainerTypeMap<P = {}, D extends React.ElementType = 'div'> {
-    props: P & FlexContainerOwnProps;
+export interface IFlexContainerTypeMap<P = object, D extends React.ElementType = 'div'> {
+    props: P & IFlexContainerOwnProps;
     defaultComponent: D;
 }
-export declare type FlexContainerProps<D extends React.ElementType = FlexContainerTypeMap['defaultComponent']> = OverrideProps<FlexContainerTypeMap<{}, D>, D> & {
+export type TFlexContainerProps<D extends React.ElementType = IFlexContainerTypeMap['defaultComponent']> = TOverrideProps<IFlexContainerTypeMap<object, D>, D> & {
     component?: D;
 };
 /**
  *
  */
-export declare const FlexContainer: OverridableComponent<FlexContainerTypeMap<{}, "div">>;
+export declare const FlexContainer: IOverridableComponent<IFlexContainerTypeMap<object, "div">>;

package/dist/types/Flex/index.d.ts

@@ -1,4 +1,4 @@
 export { Flex } from './flex';
 export { FlexContainer } from './flex_container';
-export type { FlexOwnProps, FlexProps } from './flex';
-export type { FlexContainerOwnProps, FlexContainerProps } from './flex_container';
+export type { IFlexOwnProps, TFlexProps } from './flex';
+export type { IFlexContainerOwnProps, TFlexContainerProps } from './flex_container';

package/dist/types/FocusTrap/focus_trap.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-declare type BaseProps = {
+interface IBaseProps {
     /**
      * A single child content element.
      */
@@ -14,6 +14,6 @@ declare type BaseProps = {
      * and replace it to the last focused element when it closes.
      */
     disableAutoFocus?: boolean;
-};
-export declare const FocusTrap: React.FC<BaseProps>;
+}
+export declare const FocusTrap: React.FC<IBaseProps>;
 export {};

package/dist/types/IconButton/icon_button.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
-import { OverridableComponent, OverrideProps } from '../OverridableComponent';
-import { ButtonOwnProps } from '../Button';
-import { TooltipOwnProps } from '../Tooltip';
+import { IOverridableComponent, TOverrideProps } from '../OverridableComponent';
+import { IButtonOwnProps } from '../Button';
+import { ITooltipOwnProps } from '../Tooltip';
 /**
  * Types.
  */
-export interface IconButtonOwnProps extends Omit<ButtonOwnProps, 'variant' | 'withoutPadding' | 'startIcon' | 'endIcon'> {
+export interface IIconButtonOwnProps extends Omit<IButtonOwnProps, 'variant' | 'withoutPadding' | 'startIcon' | 'endIcon'> {
     /**
      * The text that applied to `aria-label` attribute and Tooltip content.
      */
@@ -13,16 +13,16 @@ export interface IconButtonOwnProps extends Omit<ButtonOwnProps, 'variant' | 'wi
     /**
      * Props applied to the `Tooltip` element.
      */
-    tooltipProps?: Omit<TooltipOwnProps, 'open' | 'title' | 'children'>;
+    tooltipProps?: Omit<ITooltipOwnProps, 'open' | 'title' | 'children'>;
 }
-export interface IconButtonTypeMap<P = {}, D extends React.ElementType = 'button'> {
-    props: P & IconButtonOwnProps;
+export interface IIconButtonTypeMap<P = object, D extends React.ElementType = 'button'> {
+    props: P & IIconButtonOwnProps;
     defaultComponent: D;
 }
-export declare type IconButtonProps<D extends React.ElementType = IconButtonTypeMap['defaultComponent']> = OverrideProps<IconButtonTypeMap<{}, D>, D> & {
+export type TIconButtonProps<D extends React.ElementType = IIconButtonTypeMap['defaultComponent']> = TOverrideProps<IIconButtonTypeMap<object, D>, D> & {
     component?: D;
 };
 /**
  *
  */
-export declare const IconButton: OverridableComponent<IconButtonTypeMap<{}, "button">>;
+export declare const IconButton: IOverridableComponent<IIconButtonTypeMap<object, "button">>;

package/dist/types/IconButton/index.d.ts

@@ -1,2 +1,2 @@
-export { IconButton, } from './icon_button';
-export type { IconButtonOwnProps, IconButtonProps, } from './icon_button';
+export { IconButton } from './icon_button';
+export type { IIconButtonOwnProps, TIconButtonProps, } from './icon_button';

package/dist/types/Image/image.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 /**
  * Types.
  */
-declare type ImageOwnProps = {
+interface IImageOwnProps {
     /**
      * The `src` attribute for the `img` element.
      */
@@ -19,9 +19,9 @@ declare type ImageOwnProps = {
      * The className of the component.
      */
     className?: string;
-};
+}
 /**
  *
  */
-export declare const Image: React.ForwardRefExoticComponent<ImageOwnProps & Omit<React.ImgHTMLAttributes<HTMLImageElement>, "loading"> & React.RefAttributes<HTMLImageElement>>;
+export declare const Image: React.ForwardRefExoticComponent<IImageOwnProps & Omit<React.ImgHTMLAttributes<HTMLImageElement>, "loading"> & React.RefAttributes<HTMLImageElement>>;
 export {};

package/dist/types/LinearProgress/linear_progress.d.ts

@@ -2,7 +2,7 @@ import React from 'react';
 /**
  * Types.
  */
-declare type LinearProgressOwnProps = {
+interface ILinearProgressOwnProps {
     /**
      * The color of the component. It supports those theme colors that make sense for this component.
      */
@@ -15,9 +15,9 @@ declare type LinearProgressOwnProps = {
      * The className of the component.
      */
     className?: string;
-};
+}
 /**
  *
  */
-export declare const LinearProgress: React.ForwardRefExoticComponent<LinearProgressOwnProps & Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & React.RefAttributes<HTMLDivElement>>;
+export declare const LinearProgress: React.ForwardRefExoticComponent<ILinearProgressOwnProps & Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & React.RefAttributes<HTMLDivElement>>;
 export {};

package/dist/types/Menu/index.d.ts

@@ -1,2 +1,2 @@
 export { Menu } from './menu';
-export type { MenuProps } from './menu';
+export type { TMenuProps } from './menu';

package/dist/types/Menu/menu.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
-import { PopoverProps } from '../Popover';
-import { TypographyType } from '../styles';
+import { TPopoverProps } from '../Popover';
+import { TTypographyType } from '../styles';
 /**
  * Types.
  */
-declare type OptionOwnProps = {
+interface IOptionOwnProps {
     label: string;
     disabled?: boolean;
     onClick?: (event: React.MouseEvent<HTMLElement>) => void;
@@ -12,7 +12,7 @@ declare type OptionOwnProps = {
     /**
      * The variant of text to use.
      */
-    textVariant?: TypographyType;
+    textVariant?: TTypographyType;
     /**
      * Element placed before the children.
      */
@@ -21,12 +21,12 @@ declare type OptionOwnProps = {
      * Element placed after the children.
      */
     endIcon?: React.ReactNode;
+}
+type TOptionProps = IOptionOwnProps & Omit<React.AllHTMLAttributes<HTMLElement>, 'children'>;
+type TMenuOptionProps = TOptionProps & {
+    subOptions?: TOptionProps[];
 };
-declare type OptionProps = OptionOwnProps & Omit<React.AllHTMLAttributes<HTMLElement>, 'children'>;
-declare type MenuOptionProps = OptionProps & {
-    subOptions?: OptionProps[];
-};
-declare type MenuOwnProps = {
+interface IMenuOwnProps {
     /**
      * Menu reference element.
      */
@@ -34,7 +34,7 @@ declare type MenuOwnProps = {
     /**
      * Menu contents.
      */
-    options: MenuOptionProps[];
+    options: TMenuOptionProps[];
     /**
      * Callback fired when the component requests to be closed.
      */
@@ -42,11 +42,11 @@ declare type MenuOwnProps = {
     /**
      * Props applied to the `Popover` element.
      */
-    popoverProps?: Partial<PopoverProps>;
-};
-export declare type MenuProps = MenuOwnProps;
+    popoverProps?: Partial<TPopoverProps>;
+}
+export type TMenuProps = IMenuOwnProps;
 /**
  *
  */
-export declare const Menu: React.ForwardRefExoticComponent<MenuOwnProps & React.RefAttributes<HTMLDivElement>>;
+export declare const Menu: React.ForwardRefExoticComponent<IMenuOwnProps & React.RefAttributes<HTMLDivElement>>;
 export {};

package/dist/types/MenuList/menu_item.d.ts

@@ -1,10 +1,10 @@
 import React from 'react';
-import { OverridableComponent, OverrideProps } from '../OverridableComponent';
-import { TypographyType } from '../styles';
+import { IOverridableComponent, TOverrideProps } from '../OverridableComponent';
+import { TTypographyType } from '../styles';
 /**
  * Types.
  */
-declare type MenuItemOwnProps = {
+interface IMenuItemOwnProps {
     children: React.ReactNode;
     /**
      * If `true`, the component is disabled.
@@ -13,7 +13,7 @@ declare type MenuItemOwnProps = {
     /**
      * The variant of text to use.
      */
-    textVariant?: TypographyType;
+    textVariant?: TTypographyType;
     /**
      * Element placed before the children.
      */
@@ -22,16 +22,16 @@ declare type MenuItemOwnProps = {
      * Element placed after the children.
      */
     endIcon?: React.ReactNode;
-};
-export interface MenuItemTypeMap<P = {}, D extends React.ElementType = 'li'> {
-    props: P & MenuItemOwnProps;
+}
+export interface IMenuItemTypeMap<P = object, D extends React.ElementType = 'li'> {
+    props: P & IMenuItemOwnProps;
     defaultComponent: D;
 }
-export declare type MenuItemProps<D extends React.ElementType = MenuItemTypeMap['defaultComponent']> = OverrideProps<MenuItemTypeMap<{}, D>, D> & {
+export type TMenuItemProps<D extends React.ElementType = IMenuItemTypeMap['defaultComponent']> = TOverrideProps<IMenuItemTypeMap<object, D>, D> & {
     component?: D;
 };
 /**
  *
  */
-export declare const MenuItem: OverridableComponent<MenuItemTypeMap<{}, "li">>;
+export declare const MenuItem: IOverridableComponent<IMenuItemTypeMap<object, "li">>;
 export {};

package/dist/types/MenuList/menu_list.d.ts

@@ -1,20 +1,20 @@
 import React from 'react';
-import { OverridableComponent, OverrideProps } from '../OverridableComponent';
+import { IOverridableComponent, TOverrideProps } from '../OverridableComponent';
 /**
  * Types.
  */
-declare type MenuListOwnProps = {
+interface IMenuListOwnProps {
     children: React.ReactElement[];
-};
-export interface MenuListTypeMap<P = {}, D extends React.ElementType = 'ul'> {
-    props: P & MenuListOwnProps;
+}
+export interface IMenuListTypeMap<P = object, D extends React.ElementType = 'ul'> {
+    props: P & IMenuListOwnProps;
     defaultComponent: D;
 }
-export declare type MenuListProps<D extends React.ElementType = MenuListTypeMap['defaultComponent']> = OverrideProps<MenuListTypeMap<{}, D>, D> & {
+export type TMenuListProps<D extends React.ElementType = IMenuListTypeMap['defaultComponent']> = TOverrideProps<IMenuListTypeMap<object, D>, D> & {
     component?: D;
 };
 /**
  *
  */
-export declare const MenuList: OverridableComponent<MenuListTypeMap<{}, "ul">>;
+export declare const MenuList: IOverridableComponent<IMenuListTypeMap<object, "ul">>;
 export {};

package/dist/types/MenuList/sub_menu_item.d.ts

@@ -1,6 +1,6 @@
-import { OverridableComponent } from '../OverridableComponent';
-import type { MenuItemTypeMap } from './menu_item';
+import { IOverridableComponent } from '../OverridableComponent';
+import type { IMenuItemTypeMap } from './menu_item';
 /**
  *
  */
-export declare const SubMenuItem: OverridableComponent<MenuItemTypeMap<{}, "li">>;
+export declare const SubMenuItem: IOverridableComponent<IMenuItemTypeMap<object, "li">>;

package/dist/types/Modal/index.d.ts

@@ -1,2 +1,2 @@
 export { Modal } from './modal';
-export type { ModalProps } from './modal';
+export type { TModalProps } from './modal';

package/dist/types/Modal/modal.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
-import { BackdropProps } from '../Backdrop';
+import { TBackdropProps } from '../Backdrop';
 /**
  * Types.
  */
-declare type ModalOwnProps = {
+interface IModalOwnProps {
     /**
      * A single child content element.
      */
@@ -39,7 +39,7 @@ declare type ModalOwnProps = {
     /**
      * Props applied to the `Backdrop` element.
      */
-    backdropProps?: Partial<BackdropProps>;
+    backdropProps?: Partial<TBackdropProps>;
     /**
      * If `true`, the modal will not prevent focus from leaving the modal while open.
      */
@@ -50,10 +50,10 @@ declare type ModalOwnProps = {
      * and replace it to the last focused element when it closes.
      */
     disableAutoFocus?: boolean;
-};
-export declare type ModalProps = ModalOwnProps & React.HTMLAttributes<HTMLDivElement>;
+}
+export type TModalProps = IModalOwnProps & React.HTMLAttributes<HTMLDivElement>;
 /**
  *
  */
-export declare const Modal: React.ForwardRefExoticComponent<ModalOwnProps & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const Modal: React.ForwardRefExoticComponent<IModalOwnProps & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
 export {};

package/dist/types/NativeSelect/native_select.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 /**
  * Types.
  */
-declare type NativeSelectOwnProps = {
+interface INativeSelectOwnProps {
     options: {
         value: string;
         label: string;
@@ -68,9 +68,9 @@ declare type NativeSelectOwnProps = {
      * Callback fired when the value is changed.
      */
     onChange?: React.ChangeEventHandler<HTMLSelectElement>;
-};
+}
 /**
  *
  */
-export declare const NativeSelect: React.ForwardRefExoticComponent<NativeSelectOwnProps & Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> & React.RefAttributes<HTMLDivElement>>;
+export declare const NativeSelect: React.ForwardRefExoticComponent<INativeSelectOwnProps & Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> & React.RefAttributes<HTMLDivElement>>;
 export {};

package/dist/types/OverridableComponent.d.ts

@@ -3,48 +3,48 @@ import * as React from 'react';
  * Remove properties `K` from `T`.
  * Distributive for union types.
  */
-export declare type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type TDistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 /**
  * A component whose root component can be controlled via a `component` prop.
  *
  * Adjusts valid props based on the type of `component`.
  */
-export interface OverridableComponent<M extends OverridableTypeMap> {
+export interface IOverridableComponent<M extends IOverridableTypeMap> {
     <C extends React.ElementType>(props: {
         /**
          * The component used for the root node.
          * Either a string to use a HTML element or a component.
          */
         component: C;
-    } & OverrideProps<M, C>): JSX.Element | null;
-    (props: DefaultComponentProps<M>): JSX.Element | null;
+    } & TOverrideProps<M, C>): JSX.Element | null;
+    (props: TDefaultComponentProps<M>): JSX.Element | null;
     propTypes?: any;
     displayName?: string;
-    defaultProps?: Partial<DefaultComponentProps<M>>;
+    defaultProps?: Partial<TDefaultComponentProps<M>>;
 }
 /**
  * Props of the component if `component={Component}` is used.
  */
-export declare type OverrideProps<M extends OverridableTypeMap, C extends React.ElementType> = (BaseProps<M> & DistributiveOmit<React.ComponentPropsWithRef<C>, keyof BaseProps<M>>);
+export type TOverrideProps<M extends IOverridableTypeMap, C extends React.ElementType> = (TBaseProps<M> & TDistributiveOmit<React.ComponentPropsWithRef<C>, keyof TBaseProps<M>>);
 /**
  * Props if `component={Component}` is NOT used.
  */
-export declare type DefaultComponentProps<M extends OverridableTypeMap> = BaseProps<M> & DistributiveOmit<React.ComponentPropsWithRef<M['defaultComponent']>, keyof BaseProps<M>>;
+export type TDefaultComponentProps<M extends IOverridableTypeMap> = TBaseProps<M> & TDistributiveOmit<React.ComponentPropsWithRef<M['defaultComponent']>, keyof TBaseProps<M>>;
 /**
  * Props defined on the component.
  */
-export declare type BaseProps<M extends OverridableTypeMap> = M['props'] & CommonProps;
+export type TBaseProps<M extends IOverridableTypeMap> = M['props'] & ICommonProps;
 /**
  * Props that are valid for components.
  */
-export interface CommonProps {
+export interface ICommonProps {
     /**
      * The className of the component.
      */
     className?: string;
     'data-testid'?: string;
 }
-export interface OverridableTypeMap {
-    props: {};
+export interface IOverridableTypeMap {
+    props: object;
     defaultComponent: React.ElementType;
 }

package/dist/types/Popover/index.d.ts

@@ -1,2 +1,2 @@
 export { Popover } from './popover';
-export type { PopoverProps } from './popover';
+export type { TPopoverProps } from './popover';

package/dist/types/Popover/popover.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { PopperProps } from 'react-popper';
-import { ModalProps } from '../Modal';
-declare type BaseProps = {
+import { TModalProps } from '../Modal';
+interface IBaseProps {
     /**
      * If `true`, the popover is visible.
      */
@@ -25,15 +25,15 @@ declare type BaseProps = {
     /**
      * Props applied to the `Modal` element.
      */
-    modalProps?: Partial<ModalProps>;
+    modalProps?: Partial<TModalProps>;
     /**
      * Make your popover the same width as the reference.
      */
     allowUseSameWidth?: boolean;
-};
-export declare type PopoverProps = BaseProps & Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>;
+}
+export type TPopoverProps = IBaseProps & Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>;
 /**
  *
  */
-export declare const Popover: React.ForwardRefExoticComponent<BaseProps & Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & React.RefAttributes<HTMLDivElement>>;
+export declare const Popover: React.ForwardRefExoticComponent<IBaseProps & Omit<React.HTMLAttributes<HTMLDivElement>, "children"> & React.RefAttributes<HTMLDivElement>>;
 export {};

package/dist/types/Popper/popper.d.ts

@@ -3,7 +3,7 @@ import { PopperProps as PopperReactProps, Modifier } from 'react-popper';
 /**
  * Types.
  */
-declare type BaseProps = {
+interface IBaseProps {
     /**
      * If `true`, the popper is visible.
      */
@@ -33,10 +33,10 @@ declare type BaseProps = {
      * most of its features are fully encapsulated "modifiers".
      */
     modifiers?: Modifier<any>[];
-};
-declare type PopperProps = BaseProps & Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>;
+}
+type TPopperProps = IBaseProps & Omit<React.HTMLAttributes<HTMLDivElement>, 'children'>;
 /**
  *
  */
-export declare const Popper: React.FC<PopperProps>;
+export declare const Popper: React.FC<TPopperProps>;
 export {};

package/dist/types/Portal/portal.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-declare type BaseProps = {
+interface IBaseProps {
     /**
      * The content of the component.
      */
@@ -11,6 +11,6 @@ declare type BaseProps = {
      * so it's simply `document.body` most of the time.
      */
     container?: Element | (() => Element | null) | null;
-};
-export declare const Portal: React.FC<BaseProps>;
+}
+export declare const Portal: React.FC<IBaseProps>;
 export {};

package/dist/types/Radio/radio.d.ts

@@ -2,7 +2,7 @@ import * as React from 'react';
 /**
  * Types.
  */
-declare type RadioOwnProps = {
+interface IRadioOwnProps {
     /**
      * If `true`, the component is checked.
      */
@@ -47,10 +47,10 @@ declare type RadioOwnProps = {
      * Callback fired when the state is changed.
      */
     onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
-};
-export declare type RadioProps = RadioOwnProps & Omit<React.LabelHTMLAttributes<HTMLLabelElement>, 'children' | 'htmlFor' | 'onChange'>;
+}
+export type TRadioProps = IRadioOwnProps & Omit<React.LabelHTMLAttributes<HTMLLabelElement>, 'children' | 'htmlFor' | 'onChange'>;
 /**
  *
  */
-export declare const Radio: React.ForwardRefExoticComponent<RadioOwnProps & Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "children" | "htmlFor" | "onChange"> & React.RefAttributes<HTMLLabelElement>>;
+export declare const Radio: React.ForwardRefExoticComponent<IRadioOwnProps & Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "children" | "htmlFor" | "onChange"> & React.RefAttributes<HTMLLabelElement>>;
 export {};