@loadsmart/loadsmart-ui 8.0.4 → 8.0.6

package/dist/components/Accordion/Accordion.d.ts

@@ -1,11 +1,12 @@
-import { default as React, PropsWithChildren, HTMLAttributes, ReactNode } from 'react';
+import { default as React, HTMLAttributes, ReactNode } from 'react';
 export interface AccordionToggleProps {
     readonly leading?: ReactNode | ((expanded: boolean) => ReactNode);
     readonly trailing?: ReactNode | ((expanded: boolean) => ReactNode);
+    readonly children?: ReactNode;
 }
-declare function AccordionToggle({ leading, trailing: propsTrailing, children, }: PropsWithChildren<AccordionToggleProps>): React.JSX.Element;
+declare function AccordionToggle({ leading, trailing: propsTrailing, children }: AccordionToggleProps): React.JSX.Element;
 export type AccordionBodyProps = HTMLAttributes<HTMLElement>;
-declare function AccordionBody({ children, ...props }: PropsWithChildren<AccordionBodyProps>): React.JSX.Element;
+declare function AccordionBody({ children, ...props }: AccordionBodyProps): React.JSX.Element;
 export interface AccordionProps extends HTMLAttributes<HTMLElement> {
     readonly expanded?: boolean;
     readonly initialExpanded?: boolean;

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

@@ -7,12 +7,12 @@ export interface RenderableMonth {
 }
 export type CalendarMode = 'single' | 'range';
 export interface useCalendarProps {
-    year?: number;
-    month?: number;
-    mode?: CalendarMode;
-    selected?: null | [string | number | null, string | number | null];
-    onSelect?: (selection: [string | null, string | null]) => void;
-    constraints?: CalendarConstraint | CalendarConstraint[];
+    readonly year?: number;
+    readonly month?: number;
+    readonly mode?: CalendarMode;
+    readonly selected?: null | [string | number | null, string | number | null];
+    readonly onSelect?: (selection: [string | null, string | null]) => void;
+    readonly constraints?: CalendarConstraint | CalendarConstraint[];
 }
 export interface useCalendarReturn {
     mode: CalendarMode;
@@ -35,14 +35,14 @@ export type PickerModeAction = {
     payload: PickerMode;
 };
 export interface usePickerModeProps {
-    mode: PickerMode;
+    readonly mode: PickerMode;
 }
 export interface CalendarPickerProps {
-    calendar: useCalendarReturn;
-    mode: usePickerModeReturn;
-    onDayClick?: (timestamp: number) => void;
-    onMonthClick?: (month: number) => void;
-    onYearClick?: (year: number) => void;
+    readonly calendar: useCalendarReturn;
+    readonly mode: usePickerModeReturn;
+    readonly onDayClick?: (timestamp: number) => void;
+    readonly onMonthClick?: (month: number) => void;
+    readonly onYearClick?: (year: number) => void;
 }
 export interface usePickerModeReturn {
     get: () => PickerMode;
@@ -51,13 +51,13 @@ export interface usePickerModeReturn {
     Picker: (props: CalendarPickerProps) => JSX.Element;
 }
 export interface CalendarProps extends useCalendarProps, Omit<HTMLAttributes<HTMLDivElement>, 'onSelect'> {
-    onDayClick?: CalendarPickerProps['onDayClick'];
-    onMonthClick?: CalendarPickerProps['onMonthClick'];
-    onYearClick?: CalendarPickerProps['onYearClick'];
+    readonly onDayClick?: CalendarPickerProps['onDayClick'];
+    readonly onMonthClick?: CalendarPickerProps['onMonthClick'];
+    readonly onYearClick?: CalendarPickerProps['onYearClick'];
 }
 export interface GenericCalendarProps extends HTMLAttributes<HTMLDivElement> {
-    calendar: useCalendarReturn;
-    onDayClick?: CalendarPickerProps['onDayClick'];
-    onMonthClick?: CalendarPickerProps['onMonthClick'];
-    onYearClick?: CalendarPickerProps['onYearClick'];
+    readonly calendar: useCalendarReturn;
+    readonly onDayClick?: CalendarPickerProps['onDayClick'];
+    readonly onMonthClick?: CalendarPickerProps['onMonthClick'];
+    readonly onYearClick?: CalendarPickerProps['onYearClick'];
 }

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

@@ -3,7 +3,7 @@ export { default as DateFormatHelper } from './DateFormat.helper';
 export { default as DateHelper, TODAY } from './Date.helper';
 export { default as MonthHelper } from './Month.helper';
 export { default as useCalendar } from './useCalendar';
-export type { CalendarDate, CalendarDateRange, CalendarConstraint } from './Date.helper';
+export type { CalendarDate, CalendarDateRange, CalendarConstraint, InputDate } from './Date.helper';
 export type { DateFormat } from './DateFormat.helper';
 export type { CalendarMonth, CalendarMonthAlias } from './Month.helper';
 export type { CalendarProps, useCalendarProps, GenericCalendarProps } from './Calendar.types';

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

@@ -3,25 +3,25 @@ import { TextFieldProps } from '../TextField';
 import { default as EventLike } from '../../utils/types/EventLike';
 import { PopoverPlacement } from '../Popover';
 export interface DatePickerProps {
-    id?: string;
-    name: string;
-    value?: null | string | number;
-    disabled?: boolean;
-    constraints?: CalendarProps['constraints'];
-    onChange?: (event: EventLike<string | null>) => void;
-    getInputProps?: () => Partial<TextFieldProps>;
-    getCalendarProps?: () => Partial<GenericCalendarProps>;
-    placement?: PopoverPlacement;
+    readonly id?: string;
+    readonly name: string;
+    readonly value?: null | string | number;
+    readonly disabled?: boolean;
+    readonly constraints?: CalendarProps['constraints'];
+    readonly onChange?: (event: EventLike<string | null>) => void;
+    readonly getInputProps?: () => Partial<TextFieldProps>;
+    readonly getCalendarProps?: () => Partial<GenericCalendarProps>;
+    readonly placement?: PopoverPlacement;
 }
 export interface DateRangePickerProps {
-    id?: string;
-    name: string;
-    value?: useCalendarProps['selected'];
-    disabled?: boolean;
-    constraints?: CalendarProps['constraints'];
-    onChange?: (event: EventLike<null | [string | null, string | null]>) => void;
-    getRangeStartInputProps?: () => Partial<TextFieldProps>;
-    getRangeEndInputProps?: () => Partial<TextFieldProps>;
-    getCalendarProps?: () => Partial<GenericCalendarProps>;
-    placement?: PopoverPlacement;
+    readonly id?: string;
+    readonly name: string;
+    readonly value?: useCalendarProps['selected'];
+    readonly disabled?: boolean;
+    readonly constraints?: CalendarProps['constraints'];
+    readonly onChange?: (event: EventLike<null | [string | null, string | null]>) => void;
+    readonly getRangeStartInputProps?: () => Partial<TextFieldProps>;
+    readonly getRangeEndInputProps?: () => Partial<TextFieldProps>;
+    readonly getCalendarProps?: () => Partial<GenericCalendarProps>;
+    readonly placement?: PopoverPlacement;
 }

package/dist/components/Dialog/useDialog.d.ts

@@ -1,7 +1,7 @@
 export interface useDialogProps {
-    open: boolean;
-    onOpen?: () => void;
-    onClose?: () => void;
+    readonly open: boolean;
+    readonly onOpen?: () => void;
+    readonly onClose?: () => void;
 }
 declare function useDialog({ open: openProp, onOpen, onClose }: useDialogProps): {
     open: boolean;

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

@@ -1,71 +1,71 @@
 import { HTMLAttributes, ReactNode } from 'react';
 import { StackProps } from '../Layout/Stack';
 export type WrapperProps = Partial<StackProps>;
-export type DropZoneProps = Omit<HTMLAttributes<HTMLInputElement>, 'onChange'> & {
+export interface DropZoneProps extends Omit<HTMLAttributes<HTMLInputElement>, 'onChange'> {
     /**
      * Optional hint to be rendered below the main call to action text.
      */
-    hint?: string;
+    readonly hint?: string;
     /**
      * Whether the input should allow multiple files.
      */
-    multiple?: boolean;
+    readonly multiple?: boolean;
     /**
      * List (or single string) of allowed file formats.
      */
-    accept?: string | string[];
+    readonly accept?: string | string[];
     /**
      * Disables the drop zone.
      */
-    disabled?: boolean;
+    readonly disabled?: boolean;
     /**
      * Applies error styles to the drop zone wrapper.
      */
-    error?: boolean;
+    readonly error?: boolean;
     /**
      * Useful to render custom content inside the dropzone.
      * If provided, the icon, call to action, and hint won't be rendered.
      */
-    renderCustomContent?: (params: {
+    readonly renderCustomContent?: (params: {
         isDragging: boolean;
     }) => JSX.Element;
-};
+}
 export type FileStatus = 'loading' | 'error' | 'success';
 export interface FileWithStatus {
-    file: File;
-    status: FileStatus;
-    errorMessage?: string;
+    readonly file: File;
+    readonly status: FileStatus;
+    readonly errorMessage?: string;
+}
+export interface FileItemProps extends FileWithStatus {
+    readonly onRemove: () => void;
+    readonly onRetry?: () => void;
+    readonly disabled?: boolean;
 }
-export type FileItemProps = FileWithStatus & {
-    onRemove: () => void;
-    onRetry?: () => void;
-    disabled?: boolean;
-};
-export type FileListProps = Partial<StackProps> & {
+export interface FileListProps extends Partial<StackProps> {
     /**
      * Disables the buttons within the file items.
      */
-    disabled?: boolean;
-};
+    readonly disabled?: boolean;
+}
 export interface DragDropFileProviderProps {
     /**
      * List of items including the file and its status.
      */
-    fileList: FileWithStatus[];
+    readonly fileList: FileWithStatus[];
     /**
      * Function that will be triggered when new files are added to the input.
      */
-    onFilesAdded: (newFiles: File[]) => void;
+    readonly onFilesAdded: (newFiles: File[]) => void;
     /**
      * Function that will be triggered when a file is removed from the list.
      */
-    onFileRemoved: (newFileList: FileWithStatus[], removedItem: FileWithStatus, removedItemIndex: number) => void;
+    readonly onFileRemoved: (newFileList: FileWithStatus[], removedItem: FileWithStatus, removedItemIndex: number) => void;
     /**
      * Optional function to retry upload on a file item with error status.
      */
-    onRetryUpload?: (item: FileWithStatus, removedItemIndex: number) => void;
-    children: ReactNode;
+    readonly onRetryUpload?: (item: FileWithStatus, removedItemIndex: number) => void;
+    readonly children: ReactNode;
+}
+export interface DragDropFileContextValue extends Pick<DragDropFileProviderProps, 'fileList' | 'onFilesAdded' | 'onRetryUpload'> {
+    readonly onRemoveFile: (removedItem: FileWithStatus, removedItemIndex: number) => void;
 }
-export type DragDropFileContextValue = Pick<DragDropFileProviderProps, 'fileList' | 'onFilesAdded' | 'onRetryUpload'> & {
-    onRemoveFile: (removedItem: FileWithStatus, removedItemIndex: number) => void;
-};

package/dist/components/Drawer/Drawer.d.ts

@@ -1,23 +1,26 @@
-import { PropsWithChildren, ReactNode, default as React } from 'react';
+import { ReactNode, default as React } from 'react';
 export interface DrawerProps {
-    children?: ReactNode;
-    className?: string;
-    open: boolean;
-    onClose?: () => void;
-    onClickOutside?: () => void;
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly open: boolean;
+    readonly onClose?: () => void;
+    readonly onClickOutside?: () => void;
 }
 export interface DrawerHeaderProps {
     readonly className?: string;
+    readonly children?: ReactNode;
 }
-declare function DrawerHeader({ children, className, ...others }: PropsWithChildren<DrawerHeaderProps>): React.JSX.Element;
+declare function DrawerHeader({ children, className, ...others }: DrawerHeaderProps): React.JSX.Element;
 export interface DrawerBodyProps {
-    className?: string;
+    readonly className?: string;
+    readonly children?: ReactNode;
 }
-declare function DrawerBody({ children, className, ...others }: PropsWithChildren<DrawerHeaderProps>): React.JSX.Element;
+declare function DrawerBody({ children, className, ...others }: DrawerBodyProps): React.JSX.Element;
 export interface DrawerFooterProps {
     readonly className?: string;
+    readonly children?: ReactNode;
 }
-declare function DrawerFooter({ children, className, ...others }: PropsWithChildren<DrawerFooterProps>): React.JSX.Element;
+declare function DrawerFooter({ children, className, ...others }: DrawerFooterProps): React.JSX.Element;
 declare function Drawer({ className, children, open, onClose, onClickOutside, ...others }: DrawerProps): React.ReactPortal;
 declare namespace Drawer {
     var Header: typeof DrawerHeader;

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

@@ -2,8 +2,8 @@ import { PopoverPlacement } from '../Popover';
 import { ButtonProps } from '../Button';
 import { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
 export interface useDropdownProps {
-    expanded: boolean;
-    toggle: () => void;
+    readonly expanded: boolean;
+    readonly toggle: () => void;
 }
 export interface useDropdownReturn {
     expanded: boolean;
@@ -12,38 +12,38 @@ export interface useDropdownReturn {
     collapse: () => void;
 }
 export interface DropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'onBlur'>, PopoverPlacement {
-    disabled?: boolean;
+    readonly disabled?: boolean;
     /**
      * Use this prop to not allow the dropdown to be expanded.
      * While the `disabled` prop applies to the whole dropdown trigger element, this one only disables the TriggerHandle.
      */
-    expandDisabled?: boolean;
-    onBlur?: (event?: MouseEvent | TouchEvent | KeyboardEvent) => void;
+    readonly expandDisabled?: boolean;
+    readonly onBlur?: (event?: MouseEvent | TouchEvent | KeyboardEvent) => void;
 }
 export interface GenericDropdownProps extends DropdownProps, Omit<useDropdownReturn, 'expand' | 'collapse'> {
 }
-export type DropdownTriggerProps = ButtonProps & {
-    outlined?: boolean;
-};
+export interface DropdownTriggerProps extends ButtonProps {
+    readonly outlined?: boolean;
+}
 export interface DropdownMenuProps extends HTMLAttributes<HTMLDivElement> {
-    header?: ReactNode;
-    footer?: ReactNode;
+    readonly header?: ReactNode;
+    readonly footer?: ReactNode;
     /**
      * @deprecated Use the `align` prop on <Dropdown> wrapper instead.
      */
-    align?: 'start' | 'end';
+    readonly align?: 'start' | 'end';
 }
 export interface DropdownMenuItemProps extends ButtonHTMLAttributes<HTMLButtonElement> {
-    leading?: ReactNode;
-    trailing?: ReactNode;
-    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => boolean | undefined | void;
+    readonly leading?: ReactNode;
+    readonly trailing?: ReactNode;
+    readonly onClick?: (event: React.MouseEvent<HTMLButtonElement>) => boolean | undefined | void;
 }
 export interface DropdownMenuSectionProps extends HTMLAttributes<HTMLDivElement> {
-    header: ReactNode;
+    readonly header: ReactNode;
 }
 export interface DropdownContextReturn {
-    disabled: boolean;
-    expandDisabled: boolean;
-    expanded: boolean;
-    toggle: () => void;
+    readonly disabled: boolean;
+    readonly expandDisabled: boolean;
+    readonly expanded: boolean;
+    readonly toggle: () => void;
 }

package/dist/components/Dropdown/useDropdown.d.ts

@@ -1,14 +1,14 @@
 import { DropdownProps } from './Dropdown.types';
 export interface useDropdownProps {
-    expanded: boolean;
-    toggle: () => void;
+    readonly expanded: boolean;
+    readonly toggle: () => void;
 }
 export interface GenericDropdownProps extends DropdownProps, useDropdownProps {
 }
 declare function useDropdown({ disabled, expandDisabled }: DropdownProps): {
-    expanded: boolean;
-    toggle: () => void;
-    expand: () => void;
-    collapse: () => void;
+    readonly expanded: boolean;
+    readonly toggle: () => void;
+    readonly expand: () => void;
+    readonly collapse: () => void;
 };
 export default useDropdown;

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

@@ -1,22 +1,22 @@
 import { HTMLAttributes, ReactNode } from 'react';
 import { ButtonProps } from '../Button';
-export type EmptyStateCommonProps = HTMLAttributes<HTMLDivElement> & {
-    title?: string;
-    action?: Omit<ButtonProps, 'children'> & {
-        label: string;
+export interface EmptyStateCommonProps extends HTMLAttributes<HTMLDivElement> {
+    readonly title?: string;
+    readonly action?: Omit<ButtonProps, 'children'> & {
+        readonly label: string;
     };
-};
-export type EmptyStateWithIconProps = EmptyStateCommonProps & {
-    variant: 'card' | 'horizontal-card';
-    icon?: ReactNode;
-};
-export type EmptyStateWithIllustrationProps = EmptyStateCommonProps & {
-    variant: 'page' | 'panel';
-    illustration?: string | JSX.Element;
-    description?: string;
-};
+}
+export interface EmptyStateWithIconProps extends EmptyStateCommonProps {
+    readonly variant: 'card' | 'horizontal-card';
+    readonly icon?: ReactNode;
+}
+export interface EmptyStateWithIllustrationProps extends EmptyStateCommonProps {
+    readonly variant: 'page' | 'panel';
+    readonly illustration?: string | JSX.Element;
+    readonly description?: string;
+}
 export type EmptyStateProps = EmptyStateWithIconProps | EmptyStateWithIllustrationProps;
-export type IllustrationProps = HTMLAttributes<HTMLDivElement> & {
-    illustration: string | JSX.Element;
-    scale: 'default' | 'large';
-};
+export interface IllustrationProps extends HTMLAttributes<HTMLDivElement> {
+    readonly illustration: string | JSX.Element;
+    readonly scale: 'default' | 'large';
+}

package/dist/components/HighlightMatch/HighlightMatch.d.ts

@@ -1,7 +1,7 @@
 import { HTMLAttributes, default as React } from 'react';
-export type HighlightMatchProps = {
+export interface HighlightMatchProps extends HTMLAttributes<HTMLSpanElement> {
     readonly text: string;
     readonly match: string;
-} & HTMLAttributes<HTMLSpanElement>;
+}
 declare const HighlightMatch: ({ text, match, ...props }: HighlightMatchProps) => React.JSX.Element;
 export default HighlightMatch;

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

@@ -1,19 +1,21 @@
-import { PropsWithChildren, default as React } from 'react';
+import { default as React, ReactNode } from 'react';
 interface WithScaleProps {
-    scale?: 'small' | 'default' | 'large';
+    readonly scale?: 'small' | 'default' | 'large';
 }
 export interface ModalProps extends WithScaleProps {
-    className?: string;
-    id?: string;
-    open: boolean;
-    fullscreen?: boolean;
-    onOverlayClick?: () => void;
+    readonly className?: string;
+    readonly id?: string;
+    readonly open: boolean;
+    readonly fullscreen?: boolean;
+    readonly onOverlayClick?: () => void;
+    readonly children?: ReactNode;
 }
-declare function Modal({ scale, children, open, fullscreen, onOverlayClick, ...others }: PropsWithChildren<ModalProps>): React.ReactPortal;
+declare function Modal({ scale, children, open, fullscreen, onOverlayClick, ...others }: ModalProps): React.ReactPortal;
 declare namespace Modal {
-    var Header: ({ title, children }: PropsWithChildren<{
+    var Header: ({ title, children }: {
         readonly title: string;
-    }>) => React.JSX.Element;
+        readonly children?: ReactNode;
+    }) => React.JSX.Element;
     var Close: import("styled-components").StyledComponent<any, any, any, any>;
 }
 export default Modal;

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

@@ -1,48 +1,48 @@
 import { HTMLAttributes } from 'react';
 import { ButtonProps } from '../Button';
-export type PaginationProps = Omit<HTMLAttributes<HTMLElement>, 'onChange'> & {
+export interface PaginationProps extends Omit<HTMLAttributes<HTMLElement>, 'onChange'> {
     /**
      * Number of pages displayed before the ellipsis
      */
-    boundaryCount?: number;
+    readonly boundaryCount?: number;
     /**
      * The total number of pages to be shown
      */
-    count: number;
+    readonly count: number;
     /**
      * Controls if pages button should be disabled or not
      */
-    disabled?: boolean;
+    readonly disabled?: boolean;
     /**
      * Handler called every page change
      */
-    onChange: ({ page }: {
+    readonly onChange: ({ page }: {
         page: number;
     }) => void;
     /**
      * The current page number
      */
-    page: number;
+    readonly page: number;
     /**
      * Number of pages displayed next to the current page
      */
-    siblingCount?: number;
-};
+    readonly siblingCount?: number;
+}
 export type usePaginationProps = Pick<PaginationProps, 'boundaryCount' | 'count' | 'disabled' | 'onChange' | 'page' | 'siblingCount'>;
 export interface usePaginationReturn {
     'aria-current'?: boolean | undefined;
-    disabled: boolean;
-    itemType: string;
-    onClick: () => void;
-    page: number | null;
+    readonly disabled: boolean;
+    readonly itemType: string;
+    readonly onClick: () => void;
+    readonly page: number | null;
+}
+export interface PaginationItemProps extends ButtonProps {
+    readonly itemType: string;
+    readonly page: number | null;
 }
-export type PaginationItemProps = ButtonProps & {
-    itemType: string;
-    page: number | null;
-};
 export interface PaginationHelperArgs {
-    boundaryCount: number;
-    count: number;
-    page: number;
-    siblingCount: number;
+    readonly boundaryCount: number;
+    readonly count: number;
+    readonly page: number;
+    readonly siblingCount: number;
 }

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

@@ -1,5 +1,5 @@
 import { UseFloatingReturn } from '@floating-ui/react-dom';
-import { CSSProperties, HTMLAttributes, MutableRefObject, PropsWithChildren } from 'react';
+import { CSSProperties, HTMLAttributes, MutableRefObject, ReactNode } from 'react';
 export interface UsePopoverReturn {
     register: {
         setReference: UseFloatingReturn['refs']['setReference'];
@@ -23,9 +23,10 @@ export interface PopoverPlacement {
     position?: PopoverPosition;
     align?: PopoverAlign;
 }
-export type PopoverProps = PropsWithChildren<PopoverPlacement & {
-    strategy?: UsePopoverReturn['strategy'];
-    arrow?: MutableRefObject<HTMLElement | null>;
-}>;
+export interface PopoverProps extends PopoverPlacement {
+    readonly strategy?: UsePopoverReturn['strategy'];
+    readonly arrow?: MutableRefObject<HTMLElement | null>;
+    readonly children?: ReactNode;
+}
 export type PopoverReferenceProps = HTMLAttributes<HTMLDivElement>;
 export type PopoverFloatingProps = HTMLAttributes<HTMLDivElement>;

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

@@ -6,43 +6,43 @@ import { useSelectableReturn } from '../../hooks/useSelectable/useSelectable.typ
 import { ChangeEvent, ComponentType, FocusEvent, HTMLAttributes, ReactNode } from 'react';
 export type Option = Selectable;
 export interface GenericOption {
-    label: string;
-    value: SelectableKeyType;
+    readonly label: string;
+    readonly value: SelectableKeyType;
 }
 export interface SelectableOption extends GenericOption {
-    checked: boolean;
+    readonly checked: boolean;
 }
 export interface SelectableOptionProps {
-    role: string;
-    'aria-selected': boolean;
-    id: string;
-    onClick: () => boolean | undefined;
-    tabIndex: number;
+    readonly role: string;
+    readonly 'aria-selected': boolean;
+    readonly id: string;
+    readonly onClick: () => boolean | undefined;
+    readonly tabIndex: number;
 }
 export interface CreatableProps {
-    onClick: () => void;
-    tabIndex: number;
+    readonly onClick: () => void;
+    readonly tabIndex: number;
 }
 export type OptionKeyType = SelectableKeyType;
 export type SelectValue = SelectableState<Option>;
 export interface SelectAdapter<T> extends SelectableAdapter<T> {
-    getLabel: (o: T) => string;
+    readonly getLabel: (o: T) => string;
 }
 export type Adapters = Record<string, SelectAdapter<any>>;
 export interface SelectDatasource<T> {
-    type: string;
-    adapter: SelectAdapter<T>;
-    fetch: ({ query, regex }: {
+    readonly type: string;
+    readonly adapter: SelectAdapter<T>;
+    readonly fetch: ({ query, regex }: {
         query: string;
         regex: RegExp;
     }) => T[] | Promise<T[]>;
 }
 export type SelectDatasourceFunction<T> = () => SelectDatasource<T>;
 export interface SelectComponentsOptionProps {
-    value: SelectOptionProps['value'];
+    readonly value: SelectOptionProps['value'];
 }
 export interface SelectComponentsEmptyProps {
-    children: SelectEmptyProps['children'];
+    readonly children: SelectEmptyProps['children'];
 }
 export type CreatableOptionType = () => ReactNode | null;
 export interface Components {
@@ -55,27 +55,27 @@ export type OnChange = (event: EventLike<Option | Option[] | null>) => void;
 export type OnCreate = (query: string) => Promise<void | Option> | void | Option;
 export type OnQueryChange = (e: ChangeEvent<HTMLInputElement>) => void;
 export interface SelectProps extends DropdownProps {
-    name: string;
-    placeholder?: string;
-    value?: Option | Option[] | null;
-    multiple?: boolean;
-    autoFocus?: boolean;
-    datasources?: SelectDatasourceFunction<any>[];
-    options?: GenericOption[];
-    components?: Components;
-    onChange?: OnChange;
-    onCreate?: OnCreate;
-    onQueryChange?: OnQueryChange;
-    getInputProps?: () => Partial<TextFieldProps>;
-    isValidNewOption?: ((query: string) => boolean) | boolean;
-    createOptionPosition?: CreateOptionPosition;
+    readonly name: string;
+    readonly placeholder?: string;
+    readonly value?: Option | Option[] | null;
+    readonly multiple?: boolean;
+    readonly autoFocus?: boolean;
+    readonly datasources?: SelectDatasourceFunction<any>[];
+    readonly options?: GenericOption[];
+    readonly components?: Components;
+    readonly onChange?: OnChange;
+    readonly onCreate?: OnCreate;
+    readonly onQueryChange?: OnQueryChange;
+    readonly getInputProps?: () => Partial<TextFieldProps>;
+    readonly isValidNewOption?: ((query: string) => boolean) | boolean;
+    readonly createOptionPosition?: CreateOptionPosition;
     /**
      * Hide the clear button on the Single Select.
      */
-    hideClear?: boolean;
+    readonly hideClear?: boolean;
 }
 export type SelectOptionProps = {
-    value: SelectableKeyType;
+    readonly value: SelectableKeyType;
 } & Omit<DropdownMenuItemProps, keyof SelectableOptionProps | 'value'>;
 export type SelectEmptyProps = HTMLAttributes<HTMLDivElement>;
 export type SelectCreatableOptionProps = Omit<DropdownMenuItemProps, keyof CreatableProps>;