@cognitiv/components-web 1.0.4 → 1.1.0

package/dist/components/color-swatch-picker/index.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentProps } from "react";
+import { ColorSwatchPickerIndicator, ColorSwatchPickerItem, ColorSwatchPickerRoot, ColorSwatchPickerSwatch } from "./color-swatch-picker";
+export declare const ColorSwatchPicker: (({ children, className, layout, size, variant, ...props }: import("./color-swatch-picker").ColorSwatchPickerRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Indicator: ({ children, className, ...props }: import("./color-swatch-picker").ColorSwatchPickerIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    Item: ({ children, className, ...props }: import("./color-swatch-picker").ColorSwatchPickerItemProps) => import("react/jsx-runtime").JSX.Element;
+    Root: ({ children, className, layout, size, variant, ...props }: import("./color-swatch-picker").ColorSwatchPickerRootProps) => import("react/jsx-runtime").JSX.Element;
+    Swatch: ({ className, ...props }: import("./color-swatch-picker").ColorSwatchPickerSwatchProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type ColorSwatchPicker = {
+    Props: ComponentProps<typeof ColorSwatchPickerRoot>;
+    RootProps: ComponentProps<typeof ColorSwatchPickerRoot>;
+    ItemProps: ComponentProps<typeof ColorSwatchPickerItem>;
+    SwatchProps: ComponentProps<typeof ColorSwatchPickerSwatch>;
+    IndicatorProps: ComponentProps<typeof ColorSwatchPickerIndicator>;
+};
+export { ColorSwatchPickerRoot, ColorSwatchPickerItem, ColorSwatchPickerSwatch, ColorSwatchPickerIndicator, };
+export type { ColorSwatchPickerRootProps, ColorSwatchPickerRootProps as ColorSwatchPickerProps, ColorSwatchPickerItemProps, ColorSwatchPickerSwatchProps, ColorSwatchPickerIndicatorProps, } from "./color-swatch-picker";
+export { colorSwatchPickerVariants } from "./styles";
+export type { ColorSwatchPickerVariants } from "./styles";

package/dist/components/color-swatch-picker/index.js

@@ -0,0 +1,15 @@
+"use strict";
+import { ColorSwatchPickerRoot, ColorSwatchPickerSwatch, ColorSwatchPickerItem, ColorSwatchPickerIndicator } from './color-swatch-picker.js';
+export { colorSwatchPickerVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+| * Compound Component
+| * -----------------------------------------------------------------------------------------------*/
+const ColorSwatchPicker = Object.assign(ColorSwatchPickerRoot, {
+  Indicator: ColorSwatchPickerIndicator,
+  Item: ColorSwatchPickerItem,
+  Root: ColorSwatchPickerRoot,
+  Swatch: ColorSwatchPickerSwatch
+});
+
+export { ColorSwatchPicker, ColorSwatchPickerIndicator, ColorSwatchPickerItem, ColorSwatchPickerRoot, ColorSwatchPickerSwatch };

package/dist/components/color-swatch-picker/styles.d.ts

@@ -0,0 +1,120 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const colorSwatchPickerVariants: import("tailwind-variants").TVReturnType<{
+    layout: {
+        grid: {
+            base: string;
+        };
+        stack: {
+            base: string;
+        };
+    };
+    size: {
+        lg: {
+            base: string;
+        };
+        md: {
+            base: string;
+        };
+        sm: {
+            base: string;
+        };
+        xl: {
+            base: string;
+        };
+        xs: {
+            base: string;
+        };
+    };
+    variant: {
+        circle: {
+            base: string;
+        };
+        square: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    indicator: string;
+    item: string;
+    swatch: string;
+}, undefined, {
+    layout: {
+        grid: {
+            base: string;
+        };
+        stack: {
+            base: string;
+        };
+    };
+    size: {
+        lg: {
+            base: string;
+        };
+        md: {
+            base: string;
+        };
+        sm: {
+            base: string;
+        };
+        xl: {
+            base: string;
+        };
+        xs: {
+            base: string;
+        };
+    };
+    variant: {
+        circle: {
+            base: string;
+        };
+        square: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    indicator: string;
+    item: string;
+    swatch: string;
+}, import("tailwind-variants").TVReturnType<{
+    layout: {
+        grid: {
+            base: string;
+        };
+        stack: {
+            base: string;
+        };
+    };
+    size: {
+        lg: {
+            base: string;
+        };
+        md: {
+            base: string;
+        };
+        sm: {
+            base: string;
+        };
+        xl: {
+            base: string;
+        };
+        xs: {
+            base: string;
+        };
+    };
+    variant: {
+        circle: {
+            base: string;
+        };
+        square: {
+            base: string;
+        };
+    };
+}, {
+    base: string;
+    indicator: string;
+    item: string;
+    swatch: string;
+}, undefined, unknown, unknown, undefined>>;
+export type ColorSwatchPickerVariants = VariantProps<typeof colorSwatchPickerVariants>;

package/dist/components/color-swatch-picker/styles.js

@@ -0,0 +1,53 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const colorSwatchPickerVariants = tv({
+  defaultVariants: {
+    layout: "grid",
+    size: "md",
+    variant: "circle"
+  },
+  slots: {
+    base: "color-swatch-picker",
+    indicator: "color-swatch-picker__indicator",
+    item: "color-swatch-picker__item",
+    swatch: "color-swatch-picker__swatch"
+  },
+  variants: {
+    layout: {
+      grid: {
+        base: "color-swatch-picker--grid"
+      },
+      stack: {
+        base: "color-swatch-picker--stack"
+      }
+    },
+    size: {
+      lg: {
+        base: "color-swatch-picker--lg"
+      },
+      md: {
+        base: "color-swatch-picker--md"
+      },
+      sm: {
+        base: "color-swatch-picker--sm"
+      },
+      xl: {
+        base: "color-swatch-picker--xl"
+      },
+      xs: {
+        base: "color-swatch-picker--xs"
+      }
+    },
+    variant: {
+      circle: {
+        base: "color-swatch-picker--circle"
+      },
+      square: {
+        base: "color-swatch-picker--square"
+      }
+    }
+  }
+});
+
+export { colorSwatchPickerVariants };

package/dist/components/combo-box/combo-box.d.ts

@@ -0,0 +1,34 @@
+import type { ComboBoxVariants } from "./styles";
+import type { ComponentPropsWithRef, ReactNode } from "react";
+import type { ButtonProps } from "react-aria-components";
+import React from "react";
+import { ComboBox as ComboBoxPrimitive, Popover as PopoverPrimitive } from "react-aria-components";
+import { comboBoxVariants } from "./styles";
+type ComboBoxContext = {
+    slots?: ReturnType<typeof comboBoxVariants>;
+    variant?: "primary" | "secondary";
+};
+declare const ComboBoxContext: React.Context<ComboBoxContext>;
+interface ComboBoxRootProps<T extends object> extends ComponentPropsWithRef<typeof ComboBoxPrimitive<T>>, ComboBoxVariants {
+    items?: Iterable<T>;
+    /**
+     * The variant of the combo box.
+     * @default "primary"
+     */
+    variant?: "primary" | "secondary";
+}
+declare const ComboBoxRoot: <T extends object = object>({ children, className, fullWidth, menuTrigger, variant, ...props }: ComboBoxRootProps<T>) => import("react/jsx-runtime").JSX.Element;
+interface ComboBoxInputGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const ComboBoxInputGroup: ({ children, className, ...props }: ComboBoxInputGroupProps) => import("react/jsx-runtime").JSX.Element;
+interface ComboBoxTriggerProps extends ButtonProps {
+    className?: string;
+    children?: ReactNode;
+}
+declare const ComboBoxTrigger: ({ children, className, ...rest }: ComboBoxTriggerProps) => import("react/jsx-runtime").JSX.Element;
+interface ComboBoxPopoverProps extends Omit<ComponentPropsWithRef<typeof PopoverPrimitive>, "children"> {
+    children: React.ReactNode;
+}
+declare const ComboBoxPopover: ({ children, className, placement, ...props }: ComboBoxPopoverProps) => import("react/jsx-runtime").JSX.Element;
+export { ComboBoxRoot, ComboBoxInputGroup, ComboBoxTrigger, ComboBoxPopover, ComboBoxContext };
+export type { ComboBoxRootProps, ComboBoxInputGroupProps, ComboBoxTriggerProps, ComboBoxPopoverProps, };

package/dist/components/combo-box/combo-box.js

@@ -0,0 +1,116 @@
+"use client";
+import React__default, { useContext, createContext } from 'react';
+import { ComboBox, ComboBoxStateContext, Button, Popover } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { IconChevronDown } from '../icons.js';
+import { comboBoxVariants } from './styles.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { SurfaceContext } from '../surface/surface.js';
+
+const ComboBoxContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * ComboBox Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const ComboBoxRoot = ({
+  children,
+  className,
+  fullWidth,
+  menuTrigger = "focus",
+  variant,
+  ...props
+}) => {
+  const slots = React__default.useMemo(() => comboBoxVariants({
+    fullWidth
+  }), [fullWidth]);
+  return /*#__PURE__*/jsx(ComboBoxContext, {
+    value: {
+      slots,
+      variant
+    },
+    children: /*#__PURE__*/jsx(ComboBox, {
+      "data-slot": "combo-box",
+      menuTrigger: menuTrigger,
+      ...props,
+      className: composeTwRenderProps(className, slots?.base()),
+      children: values => /*#__PURE__*/jsx(Fragment, {
+        children: typeof children === "function" ? children(values) : children
+      })
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * ComboBox InputGroup
+ * -----------------------------------------------------------------------------------------------*/
+
+const ComboBoxInputGroup = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(ComboBoxContext);
+  const inputGroupClassName = composeSlotClassName(slots?.inputGroup, className);
+  return /*#__PURE__*/jsx("div", {
+    className: inputGroupClassName,
+    "data-slot": "combo-box-input-group",
+    ...props,
+    children: children
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * ComboBox Trigger
+ * -----------------------------------------------------------------------------------------------*/
+
+const ComboBoxTrigger = ({
+  children,
+  className,
+  ...rest
+}) => {
+  const {
+    slots
+  } = useContext(ComboBoxContext);
+  const state = useContext(ComboBoxStateContext);
+  return /*#__PURE__*/jsx(Button, {
+    className: composeTwRenderProps(className, slots?.trigger()),
+    "data-open": dataAttr(state?.isOpen),
+    "data-slot": "combo-box-trigger",
+    ...rest,
+    children: children ?? /*#__PURE__*/jsx(IconChevronDown, {
+      "data-slot": "combo-box-trigger-default-icon"
+    })
+  });
+};
+
+/* -------------------------------------------------------------------------------------------------
+ * ComboBox Popover
+ * -----------------------------------------------------------------------------------------------*/
+
+const ComboBoxPopover = ({
+  children,
+  className,
+  placement = "bottom",
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(ComboBoxContext);
+  return /*#__PURE__*/jsx(SurfaceContext, {
+    value: {
+      variant: "default"
+    },
+    children: /*#__PURE__*/jsx(Popover, {
+      ...props,
+      className: composeTwRenderProps(className, slots?.popover()),
+      placement: placement,
+      children: children
+    })
+  });
+};
+
+export { ComboBoxContext, ComboBoxInputGroup, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger };

package/dist/components/combo-box/index.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentProps } from "react";
+import { ComboBoxInputGroup, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger } from "./combo-box";
+export declare const ComboBox: (<T extends object = object>({ children, className, fullWidth, menuTrigger, variant, ...props }: import("./combo-box").ComboBoxRootProps<T>) => import("react/jsx-runtime").JSX.Element) & {
+    InputGroup: ({ children, className, ...props }: import("./combo-box").ComboBoxInputGroupProps) => import("react/jsx-runtime").JSX.Element;
+    Popover: ({ children, className, placement, ...props }: import("./combo-box").ComboBoxPopoverProps) => import("react/jsx-runtime").JSX.Element;
+    Root: <T extends object = object>({ children, className, fullWidth, menuTrigger, variant, ...props }: import("./combo-box").ComboBoxRootProps<T>) => import("react/jsx-runtime").JSX.Element;
+    Trigger: ({ children, className, ...rest }: import("./combo-box").ComboBoxTriggerProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type ComboBox<T extends object = object> = {
+    Props: ComponentProps<typeof ComboBoxRoot<T>>;
+    RootProps: ComponentProps<typeof ComboBoxRoot<T>>;
+    InputGroupProps: ComponentProps<typeof ComboBoxInputGroup>;
+    TriggerProps: ComponentProps<typeof ComboBoxTrigger>;
+    PopoverProps: ComponentProps<typeof ComboBoxPopover>;
+};
+export { ComboBoxInputGroup, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger };
+export type { ComboBoxRootProps, ComboBoxRootProps as ComboBoxProps, ComboBoxInputGroupProps, ComboBoxTriggerProps, ComboBoxPopoverProps, } from "./combo-box";
+export { ComboBoxContext } from "./combo-box";
+export { comboBoxVariants } from "./styles";
+export type { ComboBoxVariants } from "./styles";

package/dist/components/combo-box/index.js

@@ -0,0 +1,16 @@
+"use strict";
+import { ComboBoxRoot, ComboBoxTrigger, ComboBoxPopover, ComboBoxInputGroup } from './combo-box.js';
+export { ComboBoxContext } from './combo-box.js';
+export { comboBoxVariants } from './styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ComboBox = Object.assign(ComboBoxRoot, {
+  InputGroup: ComboBoxInputGroup,
+  Popover: ComboBoxPopover,
+  Root: ComboBoxRoot,
+  Trigger: ComboBoxTrigger
+});
+
+export { ComboBox, ComboBoxInputGroup, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger };

package/dist/components/combo-box/styles.d.ts

@@ -0,0 +1,42 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const comboBoxVariants: import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: {};
+        true: {
+            base: string;
+            inputGroup: string;
+        };
+    };
+}, {
+    base: string;
+    inputGroup: string;
+    popover: string;
+    trigger: string;
+}, undefined, {
+    fullWidth: {
+        false: {};
+        true: {
+            base: string;
+            inputGroup: string;
+        };
+    };
+}, {
+    base: string;
+    inputGroup: string;
+    popover: string;
+    trigger: string;
+}, import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: {};
+        true: {
+            base: string;
+            inputGroup: string;
+        };
+    };
+}, {
+    base: string;
+    inputGroup: string;
+    popover: string;
+    trigger: string;
+}, undefined, unknown, unknown, undefined>>;
+export type ComboBoxVariants = VariantProps<typeof comboBoxVariants>;

package/dist/components/combo-box/styles.js

@@ -0,0 +1,25 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const comboBoxVariants = tv({
+  defaultVariants: {
+    fullWidth: false
+  },
+  slots: {
+    base: "combo-box",
+    inputGroup: "combo-box__input-group",
+    popover: "combo-box__popover",
+    trigger: "combo-box__trigger"
+  },
+  variants: {
+    fullWidth: {
+      false: {},
+      true: {
+        base: "combo-box--full-width",
+        inputGroup: "combo-box__input-group--full-width"
+      }
+    }
+  }
+});
+
+export { comboBoxVariants };

package/dist/components/date-field/date-field.d.ts

@@ -0,0 +1,9 @@
+import type { DateFieldVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import type { DateValue } from "react-aria-components";
+import { DateField as DateFieldPrimitive } from "react-aria-components";
+interface DateFieldRootProps<T extends DateValue> extends ComponentPropsWithRef<typeof DateFieldPrimitive<T>>, DateFieldVariants {
+}
+declare function DateFieldRoot<T extends DateValue>({ children, className, fullWidth, ...props }: DateFieldRootProps<T>): import("react/jsx-runtime").JSX.Element;
+export { DateFieldRoot };
+export type { DateFieldRootProps };

package/dist/components/date-field/date-field.js

@@ -0,0 +1,29 @@
+"use client";
+import React__default from 'react';
+import { DateField } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { dateFieldVariants } from './styles.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+function DateFieldRoot({
+  children,
+  className,
+  fullWidth,
+  ...props
+}) {
+  const styles = React__default.useMemo(() => dateFieldVariants({
+    fullWidth
+  }), [fullWidth]);
+  return /*#__PURE__*/jsx(DateField, {
+    "data-required": dataAttr(props.isRequired),
+    "data-slot": "date-field",
+    ...props,
+    className: composeTwRenderProps(className, styles),
+    children: values => /*#__PURE__*/jsx(Fragment, {
+      children: typeof children === "function" ? children(values) : children
+    })
+  });
+}
+
+export { DateFieldRoot };

package/dist/components/date-field/index.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentProps } from "react";
+import { DateInputGroupInput, DateInputGroupInputContainer, DateInputGroupPrefix, DateInputGroupRoot, DateInputGroupSegment, DateInputGroupSuffix } from "../date-input-group";
+import { DateFieldRoot } from "./date-field";
+export declare const DateField: typeof DateFieldRoot & {
+    Group: ({ children, className, fullWidth, variant, ...props }: import("../date-input-group").DateInputGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+    Input: ({ className, ...props }: import("../date-input-group").DateInputGroupInputProps) => import("react/jsx-runtime").JSX.Element;
+    InputContainer: ({ children, className, ...props }: import("../date-input-group").DateInputGroupInputContainerProps) => import("react/jsx-runtime").JSX.Element;
+    Prefix: ({ children, className, ...props }: import("../date-input-group").DateInputGroupPrefixProps) => import("react/jsx-runtime").JSX.Element;
+    Root: typeof DateFieldRoot;
+    Segment: ({ className, segment, ...props }: import("../date-input-group").DateInputGroupSegmentProps) => import("react/jsx-runtime").JSX.Element;
+    Suffix: ({ children, className, ...props }: import("../date-input-group").DateInputGroupSuffixProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type DateField = {
+    Props: ComponentProps<typeof DateFieldRoot>;
+    RootProps: ComponentProps<typeof DateFieldRoot>;
+    GroupProps: ComponentProps<typeof DateInputGroupRoot>;
+    InputProps: ComponentProps<typeof DateInputGroupInput>;
+    InputContainerProps: ComponentProps<typeof DateInputGroupInputContainer>;
+    SegmentProps: ComponentProps<typeof DateInputGroupSegment>;
+    PrefixProps: ComponentProps<typeof DateInputGroupPrefix>;
+    SuffixProps: ComponentProps<typeof DateInputGroupSuffix>;
+};
+export { DateFieldRoot };
+export type { DateFieldRootProps, DateFieldRootProps as DateFieldProps } from "./date-field";
+export { dateFieldVariants } from "./styles";
+export type { DateFieldVariants } from "./styles";

package/dist/components/date-field/index.js

@@ -0,0 +1,20 @@
+"use strict";
+import '../date-input-group/index.js';
+import { DateFieldRoot } from './date-field.js';
+export { dateFieldVariants } from './styles.js';
+import { DateInputGroupSuffix, DateInputGroupSegment, DateInputGroupPrefix, DateInputGroupInputContainer, DateInputGroupInput, DateInputGroupRoot } from '../date-input-group/date-input-group.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const DateField = Object.assign(DateFieldRoot, {
+  Group: DateInputGroupRoot,
+  Input: DateInputGroupInput,
+  InputContainer: DateInputGroupInputContainer,
+  Prefix: DateInputGroupPrefix,
+  Root: DateFieldRoot,
+  Segment: DateInputGroupSegment,
+  Suffix: DateInputGroupSuffix
+});
+
+export { DateField, DateFieldRoot };

package/dist/components/date-field/styles.d.ts

@@ -0,0 +1,18 @@
+import type { VariantProps } from "tailwind-variants";
+export declare const dateFieldVariants: import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, "date-field", {
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    fullWidth: {
+        false: string;
+        true: string;
+    };
+}, undefined, "date-field", unknown, unknown, undefined>>;
+export type DateFieldVariants = VariantProps<typeof dateFieldVariants>;

package/dist/components/date-field/styles.js

@@ -0,0 +1,17 @@
+"use strict";
+import { tv } from 'tailwind-variants';
+
+const dateFieldVariants = tv({
+  base: "date-field",
+  defaultVariants: {
+    fullWidth: false
+  },
+  variants: {
+    fullWidth: {
+      false: "",
+      true: "date-field--full-width"
+    }
+  }
+});
+
+export { dateFieldVariants };

package/dist/components/date-input-group/date-input-group.d.ts

@@ -0,0 +1,25 @@
+import type { DateInputGroupVariants } from "./styles";
+import type { ComponentPropsWithRef } from "react";
+import type { DateInputProps as DateInputPrimitiveProps, DateSegmentProps as DateSegmentPrimitiveProps, DateInputProps as TimeInputPrimitiveProps, DateSegmentProps as TimeSegmentPrimitiveProps } from "react-aria-components";
+import { Group as GroupPrimitive } from "react-aria-components";
+interface DateInputGroupRootProps extends ComponentPropsWithRef<typeof GroupPrimitive>, DateInputGroupVariants {
+}
+declare const DateInputGroupRoot: ({ children, className, fullWidth, variant, ...props }: DateInputGroupRootProps) => import("react/jsx-runtime").JSX.Element;
+interface DateInputGroupPrefixProps extends ComponentPropsWithRef<"div"> {
+}
+declare const DateInputGroupPrefix: ({ children, className, ...props }: DateInputGroupPrefixProps) => import("react/jsx-runtime").JSX.Element;
+interface DateInputGroupInputProps extends DateInputPrimitiveProps, Partial<Omit<TimeInputPrimitiveProps, keyof DateInputPrimitiveProps>> {
+}
+declare const DateInputGroupInput: ({ className, ...props }: DateInputGroupInputProps) => import("react/jsx-runtime").JSX.Element;
+interface DateInputGroupSegmentProps extends DateSegmentPrimitiveProps, Partial<Omit<TimeSegmentPrimitiveProps, keyof DateSegmentPrimitiveProps>> {
+    className?: string;
+}
+declare const DateInputGroupSegment: ({ className, segment, ...props }: DateInputGroupSegmentProps) => import("react/jsx-runtime").JSX.Element;
+interface DateInputGroupInputContainerProps extends ComponentPropsWithRef<"div"> {
+}
+declare const DateInputGroupInputContainer: ({ children, className, ...props }: DateInputGroupInputContainerProps) => import("react/jsx-runtime").JSX.Element;
+interface DateInputGroupSuffixProps extends ComponentPropsWithRef<"div"> {
+}
+declare const DateInputGroupSuffix: ({ children, className, ...props }: DateInputGroupSuffixProps) => import("react/jsx-runtime").JSX.Element;
+export { DateInputGroupRoot, DateInputGroupInput, DateInputGroupInputContainer, DateInputGroupSegment, DateInputGroupPrefix, DateInputGroupSuffix, };
+export type { DateInputGroupRootProps, DateInputGroupInputProps, DateInputGroupInputContainerProps, DateInputGroupSegmentProps, DateInputGroupPrefixProps, DateInputGroupSuffixProps, };