@vibe/core 3.86.0 → 3.88.0

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

@@ -1,268 +1,323 @@
+import { type ActionMeta, type FocusEventHandler, type InputActionMeta, type KeyboardEventHandler, type MenuProps, type OptionProps, type OptionTypeBase, type SingleValueProps } from "react-select";
+import { type UIEventHandler, type WheelEventHandler } from "react";
 import type React from "react";
-import { type DropdownListGroup } from "./components/DropdownBaseList/DropdownBaseList.types";
 import { type VibeComponentProps } from "../../types";
-import { type BaseItemData } from "../BaseItem";
-import { type TooltipProps } from "@vibe/tooltip";
-export type DropdownOption<Item = Record<string, unknown>> = BaseItemData<Item>;
-export type DropdownGroupOption<Item = Record<string, unknown>> = DropdownListGroup<Item>[] | BaseItemData<Item>[];
-interface MultiSelectSpecifics<Item extends BaseItemData<Record<string, unknown>>> {
+export type DropdownOption = any;
+export interface CustomSingleValueProps extends SingleValueProps<DropdownOption> {
     /**
-     * If true, the dropdown allows multiple selections.
+     * The component used to render the selected value.
      */
-    multi: true;
-    multiline?: boolean;
+    Renderer: React.ComponentType;
     /**
-     * Callback fired when an option is removed in multi-select mode. Only available when multi is true.
+     * If true, the dropdown is read-only and cannot be edited.
      */
-    onOptionRemove?: (option: Item) => void;
+    readOnly: boolean;
     /**
-     * The function to call to render the selected value on single select mode.
+     * The currently selected option.
      */
-    valueRenderer?: never;
+    selectedOption: DropdownOption;
+}
+export interface CustomMenuBaseProps {
     /**
-     * The default selected values for multi-select.
+     * Class name applied to the dropdown menu wrapper.
      */
-    defaultValue?: Item[];
+    dropdownMenuWrapperClassName?: string;
     /**
-     * The controlled selected values for multi-select.
+     * The ID of the menu container.
      */
-    value?: Item[];
+    menuId?: string;
     /**
-     * Callback fired when the selected values change in multi-select mode.
+     * The ARIA label for the menu container.
      */
-    onChange?: (options: Item[]) => void;
+    menuAriaLabel?: string;
     /**
-     * Minimum number of selected chips to always show before overflowing to the counter.
+     * The ARIA label for the dropdown input.
      */
-    minVisibleCount?: number;
+    inputAriaLabel?: string;
 }
-interface SingleSelectSpecifics<Item extends BaseItemData<Record<string, unknown>>> {
+export type CustomMenuProps = CustomMenuBaseProps & MenuProps<OptionTypeBase, boolean>;
+export interface CustomOptionBaseProps {
+    optionWrapperClassName?: string;
+}
+export type CustomOptionProps = CustomOptionBaseProps & OptionProps<OptionTypeBase, boolean>;
+export type DropdownState = {
+    isDisabled: boolean;
+    selectProps: {
+        readOnly: boolean;
+    };
+};
+export interface DropdownComponentProps extends CustomMenuBaseProps, CustomOptionBaseProps, VibeComponentProps {
     /**
-     * If true, the dropdown allows multiple selections. Defaults to false.
+     * Class name applied to the dropdown's single value wrapper.
      */
-    multi?: false;
+    singleValueWrapperClassName?: string;
     /**
-     * If true, the dropdown allows multiple lines of selected items. (Not available for single select)
+     * Placeholder text displayed when no value is selected.
      */
-    multiline?: never;
+    placeholder?: string;
     /**
-     * Callback fired when an option is removed in multi-select mode. (Not available for single select)
+     * If true, the placeholder will be truncated with an ellipsis when too long.
      */
-    onOptionRemove?: never;
+    allowPlaceholderEllipsis?: boolean;
     /**
-     * The function to call to render the selected value on single select mode.
+     * If true, the dropdown is disabled.
      */
-    valueRenderer?: (option: Item) => React.ReactNode;
+    disabled?: boolean;
     /**
-     * The default selected value for single-select.
+     * If true, the dropdown is read-only and cannot be edited.
      */
-    defaultValue?: Item;
+    readOnly?: boolean;
     /**
-     * The controlled selected value for single-select.
+     * Callback fired when the dropdown menu opens.
      */
-    value?: Item;
+    onMenuOpen?: () => void;
     /**
-     * Callback fired when the selected value changes in single-select mode.
+     * Callback fired when the dropdown menu closes.
      */
-    onChange?: (option: Item) => void;
+    onMenuClose?: () => void;
     /**
-     * Minimum number of selected chips to always show before overflowing to the counter. (Not available for single select)
+     * Callback fired when a key is pressed inside the dropdown.
      */
-    minVisibleCount?: never;
-}
-type BoxModeConstraint = {
+    onKeyDown?: KeyboardEventHandler;
     /**
-     * If true, the dropdown is searchable.
+     * Callback fired when the dropdown gains focus.
      */
-    searchable?: false;
+    onFocus?: FocusEventHandler;
     /**
-     * If true, the dropdown menu is displayed inline without a popup/dialog.
+     * Callback fired when the dropdown loses focus.
      */
-    boxMode?: false;
-} | {
+    onBlur?: FocusEventHandler;
     /**
-     * If true, the dropdown is searchable.
+     * Callback fired when scrolling inside the dropdown.
      */
-    searchable: true;
+    onScroll?: UIEventHandler<HTMLDivElement>;
     /**
-     * If true, the dropdown menu is displayed inline without a popup/dialog.
+     * Callback fired when the user scrolls to the bottom of the menu.
      */
-    boxMode?: boolean;
-};
-export type BaseDropdownProps<Item extends BaseItemData<Record<string, unknown>>> = VibeComponentProps & BoxModeConstraint & {
+    onMenuScrollToBottom?: WheelEventHandler<HTMLDivElement>;
     /**
-     * The list of options available in the list.
+     * If true, prevents scrolling beyond the menu's boundaries.
      */
-    options: DropdownGroupOption<Item>;
+    captureMenuScroll?: boolean;
     /**
-     * Props to be passed to the Tooltip component that wraps the dropdown.
+     * Callback fired when the selected value changes.
      */
-    tooltipProps?: Partial<TooltipProps>;
+    onChange?: (option: DropdownOption | DropdownOption[], meta: ActionMeta<DropdownOption> | React.MouseEvent | React.KeyboardEvent) => void;
     /**
-     * If true, displays dividers between grouped options.
+     * Callback fired when the dropdown input value changes.
      */
-    withGroupDivider?: boolean;
+    onInputChange?: (newValue: string, actionMeta: InputActionMeta) => void;
     /**
-     * If true, makes the group title sticky.
+     * If true, enables search functionality within the dropdown.
      */
-    stickyGroupTitle?: boolean;
+    searchable?: boolean;
     /**
-     * The size of the dropdown.
+     * The list of options available in the dropdown.
      */
-    size?: DropdownSizes;
+    options?: DropdownOption[];
     /**
-     * The direction of the dropdown.
+     * Function to customize the "no options found" message.
      */
-    dir?: DropdownDirection;
+    noOptionsMessage?: (obj: {
+        inputValue: string;
+    }) => string | null;
     /**
-     * If true, the dropdown has no visible border by default, but shows border on hover, focus, and active states.
+     * If true, the menu opens when the dropdown gains focus.
      */
-    borderless?: boolean;
+    openMenuOnFocus?: boolean;
     /**
-     * The function to call to render an option.
+     * If true, the menu opens when the dropdown is clicked.
      */
-    optionRenderer?: (option: Item) => React.ReactNode;
+    openMenuOnClick?: boolean;
     /**
-     * The function to call to render the menu.
+     * If true, displays a clear button inside the dropdown's input.
      */
-    menuRenderer?: (props: {
-        children: React.ReactNode;
-        filteredOptions: DropdownListGroup<Item>[];
-        selectedItems: Item[];
-        getItemProps: (options: any) => Record<string, unknown>;
-    }) => React.ReactNode;
+    clearable?: boolean;
     /**
-     * The message to display when there are no options.
+     * Custom renderer for each option.
      */
-    noOptionsMessage?: string | React.ReactNode;
+    optionRenderer?: (option: DropdownOption) => JSX.Element;
     /**
-     * The placeholder to display when the dropdown is empty.
+     * Custom renderer for the selected value.
      */
-    placeholder?: string;
+    valueRenderer?: React.ReactNode | ((props: Omit<CustomSingleValueProps, "Renderer"> & DropdownOption) => React.ReactNode);
     /**
-     * If true, the dropdown is disabled.
+     *   Custom renderer for the selected value.
      */
-    disabled?: boolean;
+    ValueRenderer?: React.ReactNode;
     /**
-     * If true, the dropdown is read only.
+     * Custom renderer for the dropdown menu.
      */
-    readOnly?: boolean;
+    menuRenderer?: React.ReactElement | ((props: CustomMenuProps) => React.ReactElement);
     /**
-     * If true, the dropdown is in an error state.
+     * The placement of the dropdown menu relative to the input.
      */
-    error?: boolean;
+    menuPlacement?: DropdownMenuPlacement;
     /**
-     * The helper text to display below the dropdown.
+     * The CSS position property of the dropdown menu.
      */
-    helperText?: string;
+    menuPosition?: DropdownMenuPosition;
     /**
-     * If true, the dropdown is required.
+     * If true, the dropdown is displayed in right-to-left mode.
      */
-    required?: boolean;
+    rtl?: boolean;
     /**
-     * The label to display above the dropdown.
+     * The default selected value.
      */
-    label?: string;
+    defaultValue?: DropdownOption[];
     /**
-     * The ARIA label for the dropdown.
+     * The controlled value of the dropdown.
      */
-    ariaLabel?: string;
+    value?: DropdownOption | DropdownOption[];
     /**
-     * The ARIA label for the dropdown input.
+     * The size of the dropdown.
      */
-    inputAriaLabel?: string;
+    size?: DropdownSize;
     /**
-     * The ARIA label for the menu container.
+     * Enables async loading of options.
      */
-    menuAriaLabel?: string;
+    asyncOptions?: (inputValue: string) => Promise<DropdownOption[]>;
     /**
-     * The ARIA label for the clear button.
+     * If true, caches async-loaded options.
      */
-    clearAriaLabel?: string;
+    cacheOptions?: boolean;
     /**
-     * The current value of the input field.
+     * If true, `asyncOptions` is invoked on mount.
      */
-    inputValue?: string;
+    defaultOptions?: boolean | DropdownOption[];
+    /**
+     * If true, enables virtualization for improved performance.
+     */
+    isVirtualized?: boolean;
     /**
-     * The maximum height of the dropdown menu.
+     * The target element for the dropdown menu portal.
+     */
+    menuPortalTarget?: HTMLElement;
+    /**
+     * Custom styles for the dropdown.
+     */
+    extraStyles?: (...args: unknown[]) => unknown;
+    /**
+     * The maximum height of the menu before scrolling.
      */
     maxMenuHeight?: number;
     /**
-     * If true, controls the menu open state.
+     * The tab index of the dropdown for keyboard navigation.
+     */
+    tabIndex?: number | string;
+    /**
+     * If true, the dropdown input is automatically focused on mount.
+     */
+    autoFocus?: boolean;
+    /**
+     * If true, enables multi-select mode.
+     * When in multi-select mode, the selected value will be an array,
+     * and it will be displayed as our [`<Chips>`](/?path=/docs/components-chips--sandbox) component.
+     */
+    multi?: boolean;
+    /**
+     * If true, expands the dropdown to multiple lines when multiple values are selected.
      */
-    isMenuOpen?: boolean;
+    multiline?: boolean;
     /**
      * If true, closes the menu when an option is selected.
      */
     closeMenuOnSelect?: boolean;
     /**
-     * If true, the dropdown menu will be auto focused.
+     * If true, closes the menu when scrolling.
      */
-    autoFocus?: boolean;
+    closeMenuOnScroll?: boolean;
     /**
-     * If true, the dropdown will have a clear button.
+     * Callback fired when an option is removed in multi-select mode.
      */
-    clearable?: boolean;
+    onOptionRemove?: (option?: DropdownOption) => void;
     /**
-     * Callback fired when the dropdown loses focus.
+     * If true, prevents mandatory default options from being removed.
      */
-    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    withMandatoryDefaultOptions?: boolean;
     /**
-     * Callback fired when the clear button is clicked.
+     * Custom function to determine if an option is selected.
      */
-    onClear?: () => void;
+    isOptionSelected?: (option: DropdownOption, options: DropdownOption[]) => boolean;
     /**
-     * Callback fired when the dropdown gains focus.
+     * If true, allows the dropdown menu to overflow its container.
      */
-    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    insideOverflowContainer?: boolean;
     /**
-     * Callback fired when the dropdown input value changes.
+     * If true, allows the dropdown menu to overflow its container even with CSS transforms.
      */
-    onInputChange?: (input: string | null) => void;
+    insideOverflowWithTransformContainer?: boolean;
     /**
-     * Callback fired when a key is pressed inside the dropdown.
+     * If true, renders the dropdown menu inside its parent container in case it's inside a layer provider.
+     * Use this prop when the dropdown menu is being cut off by its parent's (such as Modal, Dialog, Tooltip, etc.)overflow settings.
      */
-    onKeyDown?: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    insideLayerContext?: boolean;
     /**
-     * Callback fired when the dropdown menu opens.
+     * Tooltip content displayed when hovering over the selected value.
      */
-    onMenuOpen?: () => void;
+    tooltipContent?: string;
     /**
-     * Callback fired when the dropdown menu closes.
+     * If true, displays a loading state inside the dropdown.
      */
-    onMenuClose?: () => void;
+    isLoading?: boolean;
     /**
-     * Callback fired when an option is selected.
+     * Function to override the default loading message.
      */
-    onOptionSelect?: (option: Item) => void;
+    loadingMessage?: (obj: {
+        inputValue: string;
+    }) => string | null;
     /**
-     * Callback fired when scrolling inside the dropdown.
+     * The ARIA label for the dropdown.
+     */
+    ariaLabel?: string;
+    /**
+     * If true, enables selecting values with the Tab key.
      */
-    onScroll?: (event: React.UIEvent<HTMLUListElement>) => void;
+    tabSelectsValue?: boolean;
     /**
-     * A function to customize the filtering of options.
-     * It receives an option and the current input value, and should return true if the option should be included, false otherwise.
+     * Custom function to filter options based on input.
      */
-    filterOption?: (option: Item, inputValue: string) => boolean;
+    filterOption?: (option: DropdownOption, inputValue: string) => boolean;
     /**
-     * If false, selected options will be hidden from the list. Defaults to true.
+     * The current value of the input field.
      */
-    showSelectedOptions?: boolean;
+    inputValue?: string;
     /**
-     * The class name to be applied to the menu wrapper.
+     * If true, the input field loses focus when an option is selected.
      */
-    menuWrapperClassName?: string;
+    blurInputOnSelect?: boolean;
     /**
-     * If true, displays a loading indicator in the dropdown controls.
+     * Custom renderer for dropdown options.
      */
-    loading?: boolean;
-} & (MultiSelectSpecifics<Item> | SingleSelectSpecifics<Item>);
-export type DropdownSizes = "small" | "medium" | "large";
-export type DropdownDirection = "ltr" | "rtl" | "auto";
-export type DropdownMultiControllerProps<Item extends BaseItemData<Record<string, unknown>>> = Omit<BaseDropdownProps<Item>, keyof MultiSelectSpecifics<Item> | keyof BoxModeConstraint> & BoxModeConstraint & MultiSelectSpecifics<Item> & {
-    dropdownRef: React.Ref<HTMLDivElement>;
-};
-export type DropdownSingleControllerProps<Item extends BaseItemData<Record<string, unknown>>> = Omit<BaseDropdownProps<Item>, keyof SingleSelectSpecifics<Item> | keyof BoxModeConstraint> & BoxModeConstraint & SingleSelectSpecifics<Item> & {
-    dropdownRef: React.Ref<HTMLDivElement>;
-};
-export {};
+    OptionRenderer?: React.ReactNode;
+    /**
+     * If true, controls the menu open state.
+     */
+    menuIsOpen?: boolean;
+    /**
+     * Callback fired when an option is selected.
+     */
+    onOptionSelect?: (option: DropdownOption) => void;
+    /**
+     * Callback fired when the clear button is clicked.
+     */
+    onClear?: () => void;
+    /**
+     * CSS selector for the container where popups are rendered.
+     */
+    popupsContainerSelector?: string;
+    /**
+     * Additional properties passed to the `react-select` component.
+     */
+    selectProps?: Record<string, string>;
+    /**
+     * If true, displays dividers between grouped options.
+     */
+    withGroupDivider?: boolean;
+    multiValueDialogClassName?: string;
+}
+export type DropdownProps = DropdownComponentProps;
+export type DropdownChipColors = "primary" | "negative" | "positive";
+export type DropdownMenuPosition = "absolute" | "fixed";
+export type DropdownMenuPlacement = "top" | "bottom" | "auto";
+export type DropdownSize = "small" | "medium" | "large";

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

@@ -0,0 +1,29 @@
+export declare const defaultCustomStyles: (baseStyles: string) => string;
+export declare const ADD_AUTO_HEIGHT_COMPONENTS: string[];
+export declare const DROPDOWN_ID = "dropdown-menu-id";
+export declare const DROPDOWN_MENU_ID = "dropdown-menu-list-id";
+export declare const DROPDOWN_MENU_ARIA_LABEL = "Dropdown menu";
+export declare const DROPDOWN_INPUT_ARIA_LABEL = "Dropdown input";
+/**
+ * @deprecated
+ */
+export declare enum DROPDOWN_CHIP_COLORS {
+    PRIMARY = "primary",
+    NEGATIVE = "negative",
+    POSITIVE = "positive"
+}
+/**
+ * @deprecated
+ */
+export declare enum DROPDOWN_MENU_POSITION {
+    ABSOLUTE = "absolute",
+    FIXED = "fixed"
+}
+/**
+ * @deprecated
+ */
+export declare enum DROPDOWN_MENU_PLACEMENT {
+    TOP = "top",
+    BOTTOM = "bottom",
+    AUTO = "auto"
+}

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

@@ -1,2 +1,5 @@
 export { default as Dropdown } from "./Dropdown";
+export { default as DropdownMenu } from "./components/menu/menu";
+export { default as DropdownOption } from "./components/option/option";
+export { default as DropdownSingleValue } from "./components/singleValue/singleValue";
 export * from "./Dropdown.types";

package/dist/components/EditableHeading/EditableHeading.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { type HeadingType, type HeadingWeight } from "@vibe/typography";
+import { HeadingTypeEnum, HeadingWeightEnum, type HeadingType, type HeadingWeight } from "@vibe/typography";
 import { type VibeComponentProps } from "../../types";
 import { type EditableTypographyImplementationProps } from "../EditableTypography/EditableTypography";
 export interface EditableHeadingProps extends VibeComponentProps, EditableTypographyImplementationProps {
@@ -12,5 +12,8 @@ export interface EditableHeadingProps extends VibeComponentProps, EditableTypogr
      */
     weight?: HeadingWeight;
 }
-declare const EditableHeading: React.ForwardRefExoticComponent<EditableHeadingProps & React.RefAttributes<HTMLElement>>;
-export default EditableHeading;
+declare const _default: React.ForwardRefExoticComponent<EditableHeadingProps & React.RefAttributes<HTMLElement>> & {
+    types: typeof HeadingTypeEnum;
+    weights: typeof HeadingWeightEnum;
+};
+export default _default;

package/dist/components/EditableText/EditableText.d.ts

@@ -1,7 +1,7 @@
 import React from "react";
 import { type VibeComponentProps } from "../../types";
 import { type EditableTypographyImplementationProps } from "../EditableTypography/EditableTypography";
-import { type TextType, type TextWeight } from "@vibe/typography";
+import { TextTypeEnum, TextWeightEnum, type TextType, type TextWeight } from "@vibe/typography";
 export interface EditableTextProps extends VibeComponentProps, EditableTypographyImplementationProps {
     /**
      * The text style variant.
@@ -16,5 +16,8 @@ export interface EditableTextProps extends VibeComponentProps, EditableTypograph
      */
     multiline?: boolean;
 }
-declare const EditableText: React.ForwardRefExoticComponent<EditableTextProps & React.RefAttributes<HTMLElement>>;
-export default EditableText;
+declare const _default: React.ForwardRefExoticComponent<EditableTextProps & React.RefAttributes<HTMLElement>> & {
+    types: typeof TextTypeEnum;
+    weights: typeof TextWeightEnum;
+};
+export default _default;

package/dist/components/FormattedNumber/FormattedNumber.d.ts

@@ -1,4 +1,5 @@
 import React from "react";
+import { formatNumber } from "../../helpers/textManipulations";
 import { type VibeComponentProps } from "../../types";
 export interface FormattedNumberProps extends VibeComponentProps {
     /**
@@ -34,5 +35,8 @@ export interface FormattedNumberProps extends VibeComponentProps {
      */
     rtl?: boolean;
 }
-declare const FormattedNumber: React.ForwardRefExoticComponent<FormattedNumberProps & React.RefAttributes<HTMLDivElement>>;
-export default FormattedNumber;
+declare const _default: React.ForwardRefExoticComponent<FormattedNumberProps & React.RefAttributes<HTMLElement>> & {
+    formatNumber: typeof formatNumber;
+    localFallBack: string;
+};
+export default _default;

package/dist/components/Label/Label.d.ts

@@ -1,4 +1,5 @@
 import React from "react";
+import { LabelKind as LabelKindEnum } from "./LabelConstants";
 import { type LabelColor, type LabelKind } from "./Label.types";
 import { type VibeComponentProps } from "../../types";
 import { type LabelSizes } from "./Label.types";
@@ -36,5 +37,53 @@ export interface LabelProps extends VibeComponentProps {
      */
     size?: LabelSizes;
 }
-declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLElement>>;
-export default Label;
+declare const _default: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLElement>> & {
+    colors: {
+        GRASS_GREEN: import("../../utils/colors-vars-map").ContentColorByName.GRASS_GREEN;
+        DONE_GREEN: import("../../utils/colors-vars-map").ContentColorByName.DONE_GREEN;
+        BRIGHT_GREEN: import("../../utils/colors-vars-map").ContentColorByName.BRIGHT_GREEN;
+        SALADISH: import("../../utils/colors-vars-map").ContentColorByName.SALADISH;
+        EGG_YOLK: import("../../utils/colors-vars-map").ContentColorByName.EGG_YOLK;
+        WORKING_ORANGE: import("../../utils/colors-vars-map").ContentColorByName.WORKING_ORANGE;
+        DARK_ORANGE: import("../../utils/colors-vars-map").ContentColorByName.DARK_ORANGE;
+        PEACH: import("../../utils/colors-vars-map").ContentColorByName.PEACH;
+        SUNSET: import("../../utils/colors-vars-map").ContentColorByName.SUNSET;
+        STUCK_RED: import("../../utils/colors-vars-map").ContentColorByName.STUCK_RED;
+        DARK_RED: import("../../utils/colors-vars-map").ContentColorByName.DARK_RED;
+        SOFIA_PINK: import("../../utils/colors-vars-map").ContentColorByName.SOFIA_PINK;
+        LIPSTICK: import("../../utils/colors-vars-map").ContentColorByName.LIPSTICK;
+        BUBBLE: import("../../utils/colors-vars-map").ContentColorByName.BUBBLE;
+        PURPLE: import("../../utils/colors-vars-map").ContentColorByName.PURPLE;
+        DARK_PURPLE: import("../../utils/colors-vars-map").ContentColorByName.DARK_PURPLE;
+        BERRY: import("../../utils/colors-vars-map").ContentColorByName.BERRY;
+        DARK_INDIGO: import("../../utils/colors-vars-map").ContentColorByName.DARK_INDIGO;
+        INDIGO: import("../../utils/colors-vars-map").ContentColorByName.INDIGO;
+        NAVY: import("../../utils/colors-vars-map").ContentColorByName.NAVY;
+        BRIGHT_BLUE: import("../../utils/colors-vars-map").ContentColorByName.BRIGHT_BLUE;
+        DARK_BLUE: import("../../utils/colors-vars-map").ContentColorByName.DARK_BLUE;
+        AQUAMARINE: import("../../utils/colors-vars-map").ContentColorByName.AQUAMARINE;
+        CHILI_BLUE: import("../../utils/colors-vars-map").ContentColorByName.CHILI_BLUE;
+        RIVER: import("../../utils/colors-vars-map").ContentColorByName.RIVER;
+        WINTER: import("../../utils/colors-vars-map").ContentColorByName.WINTER;
+        EXPLOSIVE: import("../../utils/colors-vars-map").ContentColorByName.EXPLOSIVE;
+        AMERICAN_GRAY: import("../../utils/colors-vars-map").ContentColorByName.AMERICAN_GRAY;
+        BLACKISH: import("../../utils/colors-vars-map").ContentColorByName.BLACKISH;
+        BROWN: import("../../utils/colors-vars-map").ContentColorByName.BROWN;
+        ORCHID: import("../../utils/colors-vars-map").ContentColorByName.ORCHID;
+        TAN: import("../../utils/colors-vars-map").ContentColorByName.TAN;
+        SKY: import("../../utils/colors-vars-map").ContentColorByName.SKY;
+        COFFEE: import("../../utils/colors-vars-map").ContentColorByName.COFFEE;
+        ROYAL: import("../../utils/colors-vars-map").ContentColorByName.ROYAL;
+        TEAL: import("../../utils/colors-vars-map").ContentColorByName.TEAL;
+        LAVENDER: import("../../utils/colors-vars-map").ContentColorByName.LAVENDER;
+        STEEL: import("../../utils/colors-vars-map").ContentColorByName.STEEL;
+        LILAC: import("../../utils/colors-vars-map").ContentColorByName.LILAC;
+        PECAN: import("../../utils/colors-vars-map").ContentColorByName.PECAN;
+        PRIMARY: import("./LabelConstants").LabelColor.PRIMARY;
+        DARK: import("./LabelConstants").LabelColor.DARK;
+        NEGATIVE: import("./LabelConstants").LabelColor.NEGATIVE;
+        POSITIVE: import("./LabelConstants").LabelColor.POSITIVE;
+    };
+    kinds: typeof LabelKindEnum;
+};
+export default _default;