@kaizen/components 1.22.2 → 1.23.0

package/dist/index.d.ts

@@ -16,6 +16,10 @@ import * as _kaizen_design_tokens from '@kaizen/design-tokens';
 import { Theme as Theme$1 } from '@kaizen/design-tokens';
 import { DefaultTagProps } from '@kaizen/draft-tag';
 
+type StringSuggestions<T extends string> = T | (string & Record<never, never>);
+
+type FilterDateSupportedLocales = StringSuggestions<"en-US" | "en-AU">;
+
 type CustomButtonProps = {
     id?: string;
     className: string;
@@ -90,19 +94,36 @@ type OverrideClassName<T extends Record<string, any>> = Omit<T, "className"> & {
     classNameOverride?: string;
 };
 
-interface ClearButtonProps extends Omit<OverrideClassName<ButtonHTMLAttributes<HTMLButtonElement>>, "children"> {
+type ClearButtonProps = {
     isReversed?: boolean;
-}
+} & OverrideClassName<Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children">>;
 declare const ClearButton: {
     ({ classNameOverride, isReversed, ...restProps }: ClearButtonProps): JSX.Element;
     displayName: string;
 };
 
+declare const statusCodes: readonly ["400", "401", "403", "404", "422", "500", "502", "503", "504"];
+type ErrorStatuses = (typeof statusCodes)[number];
+
+type ErrorPageProps = {
+    code: ErrorStatuses;
+    title?: string;
+    message?: React$1.ReactNode | string;
+    callToAction?: {
+        onContactSupport: () => void;
+        homeHref?: string;
+    };
+} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
+declare const ErrorPage: {
+    ({ code, title, message, callToAction, classNameOverride, }: ErrorPageProps): JSX.Element;
+    displayName: string;
+};
+
 type FilterTriggerRef = {
     triggerRef?: React.RefObject<HTMLButtonElement>;
 };
 
-interface FilterProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>> {
+type FilterProps = {
     children: React$1.ReactNode;
     isOpen: boolean;
     setIsOpen: (isOpen: boolean) => void;
@@ -113,58 +134,63 @@ interface FilterProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>>
         ref?: React$1.RefObject<FilterTriggerRef>;
     };
     onMount?: (triggerRef: React$1.RefObject<HTMLButtonElement>) => void;
-}
+} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
 declare const Filter: {
     ({ children, isOpen, setIsOpen, renderTrigger, classNameOverride, onMount, ...restProps }: FilterProps): JSX.Element;
     displayName: string;
 };
 
-interface FilterContentsProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>> {
+type FilterContentsProps = {
     children: React$1.ReactNode;
-}
+} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
 declare const FilterContents: {
     ({ children, classNameOverride, ...restProps }: FilterContentsProps): JSX.Element;
     displayName: string;
 };
 
-interface FilterButtonBaseProps extends OverrideClassName<ButtonHTMLAttributes<HTMLButtonElement>> {
+type FilterButtonBaseProps = {
     children: React$1.ReactNode;
-}
+} & OverrideClassName<ButtonHTMLAttributes<HTMLButtonElement>>;
 
-interface FilterButtonProps extends Omit<FilterButtonBaseProps, "children"> {
+type FilterButtonProps = {
     label: string;
     selectedValue?: string | JSX.Element;
     isOpen?: boolean;
-}
-declare const FilterButton: React$1.ForwardRefExoticComponent<FilterButtonProps & React$1.RefAttributes<FilterTriggerRef>>;
+} & Omit<FilterButtonBaseProps, "children">;
+declare const FilterButton: React$1.ForwardRefExoticComponent<{
+    label: string;
+    selectedValue?: string | JSX.Element | undefined;
+    isOpen?: boolean | undefined;
+} & Omit<FilterButtonBaseProps, "children"> & React$1.RefAttributes<FilterTriggerRef>>;
 
 type DataAttributes = {
     [key: `data-${string}`]: string | undefined;
 };
 
-interface ButtonGroupProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>> {
+type ButtonGroupProps = {
     children: React$1.ReactElement<FilterButtonBaseProps | TooltipProps> | Array<React$1.ReactElement<FilterButtonBaseProps | TooltipProps>>;
-}
+} & Omit<OverrideClassName<HTMLAttributes<HTMLDivElement>>, "children">;
 
-interface FilterButtonRemovableProps extends Omit<ButtonGroupProps, "children"> {
+type FilterButtonRemovableProps = {
     triggerButtonProps: FilterButtonProps & DataAttributes;
     removeButtonProps: Partial<Omit<FilterButtonBaseProps, "children">> & DataAttributes & {
         tooltipText?: string;
     };
-}
+} & Omit<ButtonGroupProps, "children">;
 type FilterButtonRemovableRefs = FilterTriggerRef & {
     removeButtonRef?: React$1.RefObject<HTMLButtonElement>;
 };
-declare const FilterButtonRemovable: React$1.ForwardRefExoticComponent<FilterButtonRemovableProps & React$1.RefAttributes<FilterButtonRemovableRefs>>;
+declare const FilterButtonRemovable: React$1.ForwardRefExoticComponent<{
+    triggerButtonProps: FilterButtonProps & DataAttributes;
+    removeButtonProps: Partial<Omit<FilterButtonBaseProps, "children">> & DataAttributes & {
+        tooltipText?: string;
+    };
+} & Omit<ButtonGroupProps, "children"> & React$1.RefAttributes<FilterButtonRemovableRefs>>;
 
-interface DateInputDescriptionProps {
+type DateInputDescriptionProps = {
     description?: string | JSX.Element;
     locale: Locale;
-}
-
-type StringSuggestions<T extends string> = T | (string & Record<never, never>);
-
-type FilterDateSupportedLocales = StringSuggestions<"en-US" | "en-AU">;
+};
 
 type DateValidationResponse = {
     date: Date | undefined;
@@ -180,7 +206,7 @@ type ValidationMessage = {
     message: string | React$1.ReactElement;
 };
 
-interface DateInputFieldProps extends Omit<DateInputProps, "id" | "labelText"> {
+type DateInputFieldProps = {
     id: string;
     locale: Locale;
     /**
@@ -191,10 +217,10 @@ interface DateInputFieldProps extends Omit<DateInputProps, "id" | "labelText"> {
     validationMessage?: ValidationMessage;
     disabled?: boolean;
     labelText?: DateInputProps["labelText"];
-}
+} & Omit<DateInputProps, "id" | "labelText">;
 
 type FilterInputProps$1<InputProps> = Omit<Partial<InputProps>, "value"> & DataAttributes;
-interface FilterDatePickerFieldProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>> {
+type FilterDatePickerFieldProps = {
     id?: string;
     locale: FilterDateSupportedLocales;
     /**
@@ -232,16 +258,16 @@ interface FilterDatePickerFieldProps extends OverrideClassName<HTMLAttributes<HT
      */
     onValidate?: (validationResponse: DateValidationResponse) => void;
     setIsFilterOpen?: FilterProps["setIsOpen"];
-}
+} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
 declare const FilterDatePickerField: ({ id: propsId, inputProps, locale: propsLocale, defaultMonth, selectedDate, onDateChange, onDateSubmit, disabledDays, description, validationMessage, onValidate, classNameOverride, ...restProps }: FilterDatePickerFieldProps) => JSX.Element;
 
-interface FilterDatePickerProps extends Omit<FilterDatePickerFieldProps, "id"> {
+type FilterDatePickerProps = {
     id?: string;
     label: string;
     isOpen: FilterProps["isOpen"];
     setIsOpen: FilterProps["setIsOpen"];
     renderTrigger: (triggerProps: FilterButtonProps) => JSX.Element;
-}
+} & Omit<FilterDatePickerFieldProps, "id">;
 declare const FilterDatePicker: {
     ({ isOpen, setIsOpen, renderTrigger, selectedDate, label, locale, onDateSubmit, ...restProps }: FilterDatePickerProps): JSX.Element;
     displayName: string;
@@ -287,14 +313,14 @@ type DateRangeFieldValidationMessage = {
     dateEnd?: ValidationMessage;
 };
 
-interface DateRangeValidationMessageProps {
+type DateRangeValidationMessageProps = {
     validationMessage?: DateRangeFieldValidationMessage;
     dateStartId?: string;
     dateEndId?: string;
     isReversed?: boolean;
-}
+};
 
-interface DateRangeInputFieldProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>> {
+type DateRangeInputFieldProps = {
     id: string;
     legend: string;
     inputStartDateProps: Omit<DateInputProps$1, "id">;
@@ -307,12 +333,12 @@ interface DateRangeInputFieldProps extends OverrideClassName<HTMLAttributes<HTML
     isReversed?: boolean;
     validationMessage?: DateRangeValidationMessageProps["validationMessage"];
     disabled?: boolean;
-}
+} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
 
 type InputStartDateProps = DateRangeInputFieldProps["inputStartDateProps"];
 type InputEndDateProps = DateRangeInputFieldProps["inputEndDateProps"];
 type FilterInputProps<InputProps> = Omit<Partial<InputProps>, "value"> & DataAttributes;
-interface FilterDateRangePickerFieldProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>> {
+type FilterDateRangePickerFieldProps = {
     id: string;
     label: string;
     locale: FilterDateSupportedLocales;
@@ -347,14 +373,14 @@ interface FilterDateRangePickerFieldProps extends OverrideClassName<HTMLAttribut
         dateStart?: (validationResponse: DateValidationResponse) => void;
         dateEnd?: (validationResponse: DateValidationResponse) => void;
     };
-}
+} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
 
-interface FilterDateRangePickerProps extends Omit<FilterDateRangePickerFieldProps, "id"> {
+type FilterDateRangePickerProps = {
     id?: string;
     isOpen: FilterProps["isOpen"];
     setIsOpen: FilterProps["setIsOpen"];
     renderTrigger: (triggerProps: FilterButtonProps) => JSX.Element;
-}
+} & Omit<FilterDateRangePickerFieldProps, "id">;
 declare const FilterDateRangePicker: {
     ({ id: propsId, isOpen, setIsOpen, renderTrigger, selectedRange, label, locale, ...restProps }: FilterDateRangePickerProps): JSX.Element;
     displayName: string;
@@ -366,30 +392,30 @@ type FilterBarDateRangePickerProps = Omit<FilterDateRangePickerProps, "id" | "la
     locale?: FilterDateRangePickerProps["locale"];
 };
 
-interface NoResultsProps extends HTMLAttributes<HTMLDivElement> {
+type NoResultsProps = {
     children: React$1.ReactNode;
-}
+} & HTMLAttributes<HTMLDivElement>;
 
-interface MenuFooterProps {
+type MenuFooterProps = {
     children: React$1.ReactNode;
-}
+};
 
-interface MenuLoadingSkeletonProps {
+type MenuLoadingSkeletonProps = {
     isAnimated?: boolean;
-}
+};
 
 type ValueType = React.Key;
-interface ItemType {
+type ItemType = {
     label: string;
     value: ValueType;
     count?: string;
     isDisabled?: boolean;
-}
+};
 type MultiSelectItem = Node<ItemType>;
 
-interface MultiSelectOptionProps {
+type MultiSelectOptionProps = {
     item: MultiSelectItem;
-}
+};
 
 type SectionNameProps = {
     /**
@@ -422,15 +448,15 @@ type ListBoxItems = {
     allItems: MultiSelectItem[];
     hasNoItems: boolean;
 };
-interface ListBoxProps {
+type ListBoxProps = {
     children: (items: ListBoxItems) => React$1.ReactNode;
-}
+};
 
-interface SearchInputProps {
+type SearchInputProps = {
     label?: string;
     id?: string;
     isLoading?: boolean;
-}
+};
 
 type FilterTriggerButtonProps = {
     label: string;
@@ -447,24 +473,24 @@ type RemovableFilterTriggerProps = FilterTriggerButtonProps & {
     onRemove: () => void;
 };
 
-interface MenuTriggerProviderProps {
+type MenuTriggerProviderProps = {
     isOpen?: boolean;
     defaultOpen?: boolean;
     onOpenChange?: (isOpen: boolean) => void;
     children: React$1.ReactNode;
-}
-interface MenuTriggerProviderContextType {
+};
+type MenuTriggerProviderContextType = {
     menuTriggerProps: HTMLAttributes<HTMLElement>;
     buttonProps: ButtonHTMLAttributes<HTMLButtonElement>;
     menuProps: AriaMenuOptions<ItemType>;
     menuTriggerState: MenuTriggerState;
     buttonRef: React$1.RefObject<HTMLButtonElement>;
-}
+};
 declare function MenuTriggerProvider({ isOpen, defaultOpen, onOpenChange, children, }: MenuTriggerProviderProps): JSX.Element;
 declare const useMenuTriggerContext: () => MenuTriggerProviderContextType;
 declare const MenuTriggerConsumer: React$1.Consumer<MenuTriggerProviderContextType>;
 
-interface SelectionProviderProps {
+type SelectionProviderProps = {
     selectionMode: SelectionMode;
     children: React$1.ReactNode;
     items?: ItemType[];
@@ -476,15 +502,15 @@ interface SelectionProviderProps {
     label: string;
     disabledKeys?: Selection;
     onSearchInputChange?: (searchInput: string) => void;
-}
-interface SelectionProviderContextType {
+};
+type SelectionProviderContextType = {
     listBoxProps: HTMLAttributes<HTMLElement>;
     labelProps: HTMLAttributes<HTMLElement>;
     selectionState: ListState<ItemType>;
     listRef: React$1.RefObject<HTMLUListElement>;
     searchQuery?: string;
     setSearchQuery: React$1.Dispatch<React$1.SetStateAction<string>>;
-}
+};
 declare const SelectionProvider: {
     (props: SelectionProviderProps): JSX.Element;
     displayName: string;
@@ -492,13 +518,13 @@ declare const SelectionProvider: {
 declare const useSelectionContext: () => SelectionProviderContextType;
 declare const SelectionConsumer: React$1.Consumer<SelectionProviderContextType>;
 
-interface MenuPopupProps {
+type MenuPopupProps = {
     isLoading?: boolean;
     loadingSkeleton?: React$1.ReactNode;
     children: React$1.ReactNode;
-}
+};
 
-interface SelectionProps {
+type SelectionProps = {
     label: string;
     items: ItemType[];
     selectedKeys?: Selection;
@@ -506,11 +532,11 @@ interface SelectionProps {
     onSelectionChange?: (keys: Selection) => void;
     selectionMode?: SelectionMode;
     onSearchInputChange?: (searchInput: string) => void;
-}
-interface RootProps extends Omit<MenuPopupProps, "children">, Omit<MenuTriggerProviderProps, "children">, SelectionProps {
+};
+type RootProps = {
     trigger: (value?: MenuTriggerProviderContextType) => React$1.ReactNode;
     children: (value?: SelectionProviderContextType) => React$1.ReactNode;
-}
+} & Omit<MenuPopupProps, "children"> & Omit<MenuTriggerProviderProps, "children"> & SelectionProps;
 
 type FilterMultiSelectProps = RootProps;
 declare const FilterMultiSelect: {
@@ -591,31 +617,31 @@ type SelectOptionGroup<Option extends SelectOption> = {
     options: Iterable<Option>;
 };
 type SelectItem<Option extends SelectOption = SelectOption> = Option | SelectOptionGroup<Option>;
-interface SelectOptionNode<Option extends SelectOption = SelectOption> extends Node<Option> {
+type SelectOptionNode<Option extends SelectOption = SelectOption> = Node<Option> & {
     type: "item";
     hasChildNodes: false;
-}
-interface SelectOptionGroupNode<Option extends SelectOption = SelectOption> extends Omit<Node<SelectOptionGroup<Option>>, "childNodes"> {
+};
+type SelectOptionGroupNode<Option extends SelectOption = SelectOption> = Omit<Node<SelectOptionGroup<Option>>, "childNodes"> & {
     type: "section";
     hasChildNodes: true;
     childNodes: Array<SelectOptionNode<Option>>;
-}
+};
 type SelectItemNode<Option extends SelectOption = SelectOption> = SelectOptionNode<Option> | SelectOptionGroupNode<Option>;
 
 type ListItemProps<Option extends SelectOption = SelectOption> = {
     item: SelectItemNode<Option>;
 };
 
-interface OptionProps<Option extends SelectOption = SelectOption> extends OverrideClassName<Omit<HTMLAttributes<HTMLLIElement>, "children">> {
+type OptionProps<Option extends SelectOption = SelectOption> = {
     item: SelectOptionNode<Option>;
-}
+} & OverrideClassName<Omit<HTMLAttributes<HTMLLIElement>, "children">>;
 
-interface ListBoxSectionProps<Option extends SelectOption> {
+type ListBoxSectionProps<Option extends SelectOption> = {
     section: SelectOptionGroupNode<Option>;
-}
+};
 
 type OmittedAriaSelectProps = "label" | "children" | "isOpen" | "onOpenChange" | "defaultOpen" | "items";
-interface FilterSelectProps<Option extends SelectOption = SelectOption> extends OverrideClassName<Omit<SelectProps<Option>, OmittedAriaSelectProps>> {
+type FilterSelectProps<Option extends SelectOption = SelectOption> = {
     isOpen: boolean;
     setIsOpen: (isOpen: boolean) => void;
     renderTrigger: (triggerButtonProps: FilterButtonProps) => JSX.Element;
@@ -624,7 +650,7 @@ interface FilterSelectProps<Option extends SelectOption = SelectOption> extends
         items: Array<SelectItemNode<Option>>;
     }) => React$1.ReactNode;
     items: Array<SelectItem<Option>>;
-}
+} & OverrideClassName<Omit<SelectProps<Option>, OmittedAriaSelectProps>>;
 declare const FilterSelect: {
     <Option extends SelectOption = SelectOption>({ isOpen, setIsOpen, renderTrigger, label, children, items, classNameOverride, selectedKey, ...restProps }: FilterSelectProps<Option>): JSX.Element;
     displayName: string;
@@ -754,13 +780,13 @@ declare const FilterBar: {
     };
 };
 
-interface InputSearchProps extends OverrideClassName<Omit<InputHTMLAttributes<HTMLInputElement>, "defaultValue">> {
+type InputSearchProps = {
     id: string;
     reversed?: boolean;
     loading?: boolean;
     secondary?: boolean;
     onClear?: () => void;
-}
+} & OverrideClassName<Omit<InputHTMLAttributes<HTMLInputElement>, "defaultValue">>;
 declare const InputSearch: {
     (props: InputSearchProps): JSX.Element;
     displayName: string;
@@ -1034,46 +1060,46 @@ declare const ThemeProvider: ({ themeManager, ...props }: {
 }) => JSX.Element;
 declare const useTheme: () => Theme;
 
-interface KaizenProviderProps {
+type KaizenProviderProps = {
     children: React$1.ReactNode;
     themeManager?: ThemeManager;
     locale?: string;
-}
+};
 declare const KaizenProvider: {
     ({ children, themeManager, locale, }: KaizenProviderProps): JSX.Element;
     displayName: string;
 };
 
-interface ProgressStepperProps {
+type ProgressStepperProps = {
     stepName: string;
     steps: [string, ...string[]];
     isComplete?: boolean;
-}
+};
 
-interface FooterProps extends OverrideClassName<Omit<HTMLAttributes<HTMLElement>, "children">>, ProgressStepperProps {
+type FooterProps = {
     /** An action to return to a previous step */
     previousAction?: JSX.Element;
     /** An action to progress to the next step or submit the form */
     nextAction?: JSX.Element;
-}
+} & ProgressStepperProps & OverrideClassName<Omit<HTMLAttributes<HTMLElement>, "children">>;
 
 type WorkflowStatus = {
     /** @default: "statusDraft" */
     variant?: DefaultTagProps["variant"];
     content?: string;
 };
-interface WorkflowTitlesProps extends OverrideClassName<HTMLAttributes<HTMLDivElement>> {
+type WorkflowTitlesProps = {
     workflowName: string;
     stepName: string;
     status?: WorkflowStatus;
-}
+} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
 
-interface WorkflowActionsProps extends OverrideClassName<Omit<HTMLAttributes<HTMLDivElement>, "children">> {
+type WorkflowActionsProps = {
     /**
      * Header actions will render in order of the array.
      */
     headerActions?: JSX.Element[];
-}
+} & OverrideClassName<Omit<HTMLAttributes<HTMLDivElement>, "children">>;
 
 type HeaderProps = WorkflowTitlesProps & WorkflowActionsProps;
 
@@ -1112,21 +1138,4 @@ declare const Workflow: (({ stepName, steps, isComplete, workflowName, status, h
     };
 };
 
-declare const statusCodes: readonly ["400", "401", "403", "404", "422", "500", "502", "503", "504"];
-type ErrorStatuses = (typeof statusCodes)[number];
-
-type ErrorPageProps = {
-    code: ErrorStatuses;
-    title?: string;
-    message?: React$1.ReactNode | string;
-    callToAction?: {
-        onContactSupport: () => void;
-        homeHref?: string;
-    };
-} & OverrideClassName<HTMLAttributes<HTMLDivElement>>;
-declare function ErrorPage({ code, title, message, callToAction, classNameOverride, }: ErrorPageProps): JSX.Element;
-declare namespace ErrorPage {
-    var displayName: string;
-}
-
 export { ActiveFiltersArray, BadgeProps, Button, ButtonFormAttributes, ButtonProps, ButtonRef, ButtonType, CSSVariableTheme, ClearButton, ClearButtonProps, CustomButtonProps, DateRangeFieldValidationMessage, DateValidationResponse, DeepMapObjectLeafs, ErrorPage, ErrorPageProps, Filter, FilterAttributes, FilterBar, FilterBarContextValue, FilterBarProps, FilterBarProvider, FilterBarProviderProps, FilterBarState, FilterBarStateFilters, FilterButton, FilterButtonProps, FilterButtonRemovable, FilterButtonRemovableProps, FilterButtonRemovableRefs, FilterContents, FilterContentsProps, FilterDatePicker, FilterDatePickerField, FilterDatePickerFieldProps, FilterDatePickerProps, FilterDateRangePicker, FilterDateRangePickerProps, FilterDateSupportedLocales, FilterIsUsableWhen, FilterMultiSelect, FilterMultiSelectProps, FilterProps, FilterSelect, FilterSelectProps, FilterState, FilterStateEditableAttributes, FilterTriggerButtonProps, FilterTriggerRef, Filters, FiltersValues, GenericProps, GetDateValidationHandlerArgs, InputSearch, InputSearchProps, InternalFilterState, ItemType, KaizenProvider, KaizenProviderProps, ListBoxItems, ListBoxProps, ListBoxSectionProps$1 as ListBoxSectionProps, LoadMoreButtonProps, MappedFilters, MenuFooterProps, MenuLoadingSkeletonProps, MenuTriggerConsumer, MenuTriggerProvider, MenuTriggerProviderContextType, MenuTriggerProviderProps, MultiSelectItem, MultiSelectOptionProps, NoResultsProps, RemovableFilterTriggerProps, RenderProps, SearchInputProps, SelectItem, SelectItemNode, SelectOption, SelectOptionGroup, SelectOptionGroupNode, SelectOptionNode, SelectionConsumer, SelectionProvider, SelectionProviderContextType, SelectionProviderProps, SourceFiltersState, Theme, ThemeContext, ThemeKey, ThemeManager, ThemeProvider, TypographyFont, UseDateValidationArgs, UseDateValidationValue, ValidateDateResponse, ValidationMessage, ValueType, Workflow, WorkflowProps, WorkingProps, WorkingUndefinedProps, defaultTheme, getDateValidationHandler, getSelectedOptionKeys, getSelectedOptionLabels, getTruncatedLabels, heartTheme, useDateValidation, useFilterBarContext, useMenuTriggerContext, useSelectionContext, useTheme, validateDate };