@arobo/react 1.0.1

package/dist/components/checkbox/checkbox.js

@@ -0,0 +1,123 @@
+import React, { useContext, createContext } from 'react';
+import { Checkbox } from 'react-aria-components';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { CheckboxGroupContext } from '../checkbox-group/checkbox-group.js';
+import { jsx } from 'react/jsx-runtime';
+import { checkboxVariants } from '../../styles/src/components/checkbox/checkbox.styles.js';
+
+const CheckboxContext = /*#__PURE__*/createContext({});
+const CheckboxRoot = ({
+  children,
+  className,
+  variant,
+  ...props
+}) => {
+  const checkboxGroupContext = useContext(CheckboxGroupContext);
+  const effectiveVariant = variant ?? checkboxGroupContext.variant;
+  const slots = React.useMemo(() => checkboxVariants({
+    variant: effectiveVariant
+  }), [effectiveVariant]);
+  return /*#__PURE__*/jsx(Checkbox, {
+    "data-slot": "checkbox",
+    ...props,
+    className: composeTwRenderProps(className, slots.base()),
+    children: values => /*#__PURE__*/jsx(CheckboxContext, {
+      value: {
+        slots,
+        state: values
+      },
+      children: typeof children === "function" ? children(values) : children
+    })
+  });
+};
+
+/* -----------------------------------------------------------------------------------------------*/
+
+const CheckboxControl = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CheckboxContext);
+  return /*#__PURE__*/jsx("span", {
+    className: composeSlotClassName(slots?.control, className),
+    "data-slot": "checkbox-control",
+    ...props,
+    children: children
+  });
+};
+
+/* -----------------------------------------------------------------------------------------------*/
+
+const CheckboxIndicator = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots,
+    state
+  } = useContext(CheckboxContext);
+  const isSelected = state?.isSelected;
+  const isIndeterminate = state?.isIndeterminate;
+  const content = typeof children === "function" ? children(state ?? {}) : children ? children : isIndeterminate ? /*#__PURE__*/jsx("svg", {
+    "aria-hidden": "true",
+    "data-slot": "checkbox-default-indicator--indeterminate",
+    fill: "none",
+    role: "presentation",
+    stroke: "currentColor",
+    strokeLinecap: "round",
+    strokeWidth: 3,
+    viewBox: "0 0 24 24",
+    children: /*#__PURE__*/jsx("line", {
+      x1: "21",
+      x2: "3",
+      y1: "12",
+      y2: "12"
+    })
+  }) : /*#__PURE__*/jsx("svg", {
+    "aria-hidden": "true",
+    "data-slot": "checkbox-default-indicator--checkmark",
+    fill: "none",
+    role: "presentation",
+    stroke: "currentColor",
+    strokeDasharray: 22,
+    strokeDashoffset: isSelected ? 44 : 66,
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    strokeWidth: 2,
+    viewBox: "0 0 17 18",
+    children: /*#__PURE__*/jsx("polyline", {
+      points: "1 9 7 14 15 4"
+    })
+  });
+  return /*#__PURE__*/jsx("span", {
+    "aria-hidden": "true",
+    className: composeSlotClassName(slots?.indicator, className),
+    "data-slot": "checkbox-indicator",
+    ...props,
+    children: content
+  });
+};
+
+/* -----------------------------------------------------------------------------------------------*/
+
+const CheckboxContent = ({
+  children,
+  className,
+  ...props
+}) => {
+  const {
+    slots
+  } = useContext(CheckboxContext);
+  return /*#__PURE__*/jsx("div", {
+    className: composeSlotClassName(slots?.content, className),
+    "data-slot": "checkbox-content",
+    ...props,
+    children: children
+  });
+};
+
+export { CheckboxContent, CheckboxControl, CheckboxIndicator, CheckboxRoot };

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

@@ -0,0 +1,19 @@
+import type { ComponentProps } from "react";
+import { CheckboxContent, CheckboxControl, CheckboxIndicator, CheckboxRoot } from "./checkbox";
+export declare const Checkbox: (({ children, className, variant, ...props }: import("./checkbox").CheckboxRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, variant, ...props }: import("./checkbox").CheckboxRootProps) => import("react/jsx-runtime").JSX.Element;
+    Control: ({ children, className, ...props }: import("./checkbox").CheckboxControlProps) => import("react/jsx-runtime").JSX.Element;
+    Indicator: ({ children, className, ...props }: import("./checkbox").CheckboxIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ children, className, ...props }: import("./checkbox").CheckboxContentProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type Checkbox = {
+    Props: ComponentProps<typeof CheckboxRoot>;
+    RootProps: ComponentProps<typeof CheckboxRoot>;
+    ControlProps: ComponentProps<typeof CheckboxControl>;
+    IndicatorProps: ComponentProps<typeof CheckboxIndicator>;
+    ContentProps: ComponentProps<typeof CheckboxContent>;
+};
+export { CheckboxRoot, CheckboxControl, CheckboxIndicator, CheckboxContent, } from "./checkbox";
+export type { CheckboxRootProps, CheckboxRootProps as CheckboxProps, CheckboxControlProps, CheckboxIndicatorProps, CheckboxContentProps, } from "./checkbox";
+export { checkboxVariants } from "@arobo/styles";
+export type { CheckboxVariants } from "@arobo/styles";

package/dist/components/checkbox/index.js

@@ -0,0 +1,14 @@
+import { CheckboxRoot, CheckboxContent, CheckboxIndicator, CheckboxControl } from './checkbox.js';
+export { checkboxVariants } from '../../styles/src/components/checkbox/checkbox.styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const Checkbox = Object.assign(CheckboxRoot, {
+  Root: CheckboxRoot,
+  Control: CheckboxControl,
+  Indicator: CheckboxIndicator,
+  Content: CheckboxContent
+});
+
+export { Checkbox, CheckboxContent, CheckboxControl, CheckboxIndicator, CheckboxRoot };

package/dist/components/checkbox-group/checkbox-group.d.ts

@@ -0,0 +1,14 @@
+import type { CheckboxVariants } from "../checkbox";
+import type { CheckboxGroupVariants } from "@arobo/styles";
+import type { ComponentPropsWithRef } from "react";
+import React from "react";
+import { CheckboxGroup as CheckboxGroupPrimitive } from "react-aria-components";
+interface CheckboxGroupContext {
+    variant?: CheckboxVariants["variant"];
+}
+declare const CheckboxGroupContext: React.Context<CheckboxGroupContext>;
+interface CheckboxGroupProps extends ComponentPropsWithRef<typeof CheckboxGroupPrimitive>, CheckboxGroupVariants {
+}
+declare const CheckboxGroup: ({ children, className, variant, ...props }: CheckboxGroupProps) => import("react/jsx-runtime").JSX.Element;
+export { CheckboxGroup, CheckboxGroupContext };
+export type { CheckboxGroupProps };

package/dist/components/checkbox-group/checkbox-group.js

@@ -0,0 +1,32 @@
+import React, { createContext } from 'react';
+import { CheckboxGroup as CheckboxGroup$1 } from 'react-aria-components';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { checkboxGroupVariants } from '../../styles/src/components/checkbox-group/checkbox-group.styles.js';
+
+const CheckboxGroupContext = /*#__PURE__*/createContext({});
+const CheckboxGroup = ({
+  children,
+  className,
+  variant,
+  ...props
+}) => {
+  const styles = React.useMemo(() => checkboxGroupVariants({
+    variant
+  }), [variant]);
+  return /*#__PURE__*/jsx(CheckboxGroupContext.Provider, {
+    value: {
+      variant
+    },
+    children: /*#__PURE__*/jsx(CheckboxGroup$1, {
+      className: composeTwRenderProps(className, styles),
+      "data-slot": "checkbox-group",
+      ...props,
+      children: values => /*#__PURE__*/jsx(Fragment, {
+        children: typeof children === "function" ? children(values) : children
+      })
+    })
+  });
+};
+
+export { CheckboxGroup, CheckboxGroupContext };

package/dist/components/checkbox-group/index.d.ts

@@ -0,0 +1,3 @@
+export { CheckboxGroup } from "./checkbox-group";
+export type { CheckboxGroupProps } from "./checkbox-group";
+export { checkboxGroupVariants, type CheckboxGroupVariants, } from "@arobo/styles";

package/dist/components/checkbox-group/index.js

@@ -0,0 +1,2 @@
+export { CheckboxGroup } from './checkbox-group.js';
+export { checkboxGroupVariants } from '../../styles/src/components/checkbox-group/checkbox-group.styles.js';

package/dist/components/close-button/close-button.d.ts

@@ -0,0 +1,8 @@
+import type { CloseButtonVariants } from "@arobo/styles";
+import type { ComponentPropsWithRef } from "react";
+import { Button as ButtonPrimitive } from "react-aria-components";
+interface CloseButtonRootProps extends ComponentPropsWithRef<typeof ButtonPrimitive>, CloseButtonVariants {
+}
+declare const CloseButtonRoot: ({ children, className, slot, style, variant, ...rest }: CloseButtonRootProps) => import("react/jsx-runtime").JSX.Element;
+export { CloseButtonRoot };
+export type { CloseButtonRootProps };

package/dist/components/close-button/close-button.js

@@ -0,0 +1,32 @@
+import { useMemo } from 'react';
+import { Button } from 'react-aria-components';
+import { CloseIcon } from '../icons.js';
+import { jsx } from 'react/jsx-runtime';
+import { closeButtonVariants } from '../../styles/src/components/close-button/close-button.styles.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+
+const CloseButtonRoot = ({
+  children,
+  className,
+  slot,
+  style,
+  variant,
+  ...rest
+}) => {
+  const styles = useMemo(() => closeButtonVariants({
+    variant
+  }), [variant]);
+  return /*#__PURE__*/jsx(Button, {
+    "aria-label": "Close",
+    className: composeTwRenderProps(className, styles),
+    "data-slot": "close-button",
+    slot: slot,
+    style: style,
+    ...rest,
+    children: renderProps => typeof children === "function" ? children(renderProps) : children ?? /*#__PURE__*/jsx(CloseIcon, {
+      "data-slot": "close-button-icon"
+    })
+  });
+};
+
+export { CloseButtonRoot };

package/dist/components/close-button/index.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentProps } from "react";
+import { CloseButtonRoot } from "./close-button";
+export declare const CloseButton: (({ children, className, slot, style, variant, ...rest }: import("./close-button").CloseButtonRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, className, slot, style, variant, ...rest }: import("./close-button").CloseButtonRootProps) => import("react/jsx-runtime").JSX.Element;
+};
+export type CloseButton = {
+    Props: ComponentProps<typeof CloseButtonRoot>;
+    RootProps: ComponentProps<typeof CloseButtonRoot>;
+};
+export { CloseButtonRoot };
+export type { CloseButtonRootProps, CloseButtonRootProps as CloseButtonProps, } from "./close-button";
+export { closeButtonVariants } from "@arobo/styles";
+export type { CloseButtonVariants } from "@arobo/styles";

package/dist/components/close-button/index.js

@@ -0,0 +1,11 @@
+import { CloseButtonRoot } from './close-button.js';
+export { closeButtonVariants } from '../../styles/src/components/close-button/close-button.styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const CloseButton = Object.assign(CloseButtonRoot, {
+  Root: CloseButtonRoot
+});
+
+export { CloseButton, CloseButtonRoot };

package/dist/components/combobox/combobox.d.ts

@@ -0,0 +1,23 @@
+import type { ComboBoxVariants } from "@arobo/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";
+interface ComboBoxRootProps<T extends object> extends ComponentPropsWithRef<typeof ComboBoxPrimitive<T>>, ComboBoxVariants {
+    items?: Iterable<T>;
+}
+declare const ComboBoxRoot: <T extends object = object>({ children, className, fullWidth, menuTrigger, ...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 };
+export type { ComboBoxRootProps, ComboBoxInputGroupProps, ComboBoxTriggerProps, ComboBoxPopoverProps, };

package/dist/components/combobox/combobox.js

@@ -0,0 +1,113 @@
+import React, { createContext, useContext } from 'react';
+import { ComboBox, Popover, ComboBoxStateContext, Button } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps, composeSlotClassName } from '../../utils/compose.js';
+import { IconChevronDown } from '../icons.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { comboboxVariants } from '../../styles/src/components/combobox/combobox.styles.js';
+import { SurfaceContext } from '../surface/surface.js';
+
+const ComboBoxContext = /*#__PURE__*/createContext({});
+
+/* -------------------------------------------------------------------------------------------------
+ * ComboBox Root
+ * -----------------------------------------------------------------------------------------------*/
+
+const ComboBoxRoot = ({
+  children,
+  className,
+  fullWidth,
+  menuTrigger = "focus",
+  ...props
+}) => {
+  const slots = React.useMemo(() => comboboxVariants({
+    fullWidth
+  }), [fullWidth]);
+  return /*#__PURE__*/jsx(ComboBoxContext, {
+    value: {
+      slots
+    },
+    children: /*#__PURE__*/jsx(ComboBox, {
+      "data-slot": "combobox",
+      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": "combobox-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": "combobox-trigger",
+    ...rest,
+    children: children ?? /*#__PURE__*/jsx(IconChevronDown, {
+      "data-slot": "combobox-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 { ComboBoxInputGroup, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger };

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

@@ -0,0 +1,19 @@
+import type { ComponentProps } from "react";
+import { ComboBoxInputGroup, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger } from "./combobox";
+export declare const ComboBox: (<T extends object = object>({ children, className, fullWidth, menuTrigger, ...props }: import("./combobox").ComboBoxRootProps<T>) => import("react/jsx-runtime").JSX.Element) & {
+    Root: <T extends object = object>({ children, className, fullWidth, menuTrigger, ...props }: import("./combobox").ComboBoxRootProps<T>) => import("react/jsx-runtime").JSX.Element;
+    InputGroup: ({ children, className, ...props }: import("./combobox").ComboBoxInputGroupProps) => import("react/jsx-runtime").JSX.Element;
+    Trigger: ({ children, className, ...rest }: import("./combobox").ComboBoxTriggerProps) => import("react/jsx-runtime").JSX.Element;
+    Popover: ({ children, className, placement, ...props }: import("./combobox").ComboBoxPopoverProps) => 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 "./combobox";
+export { comboboxVariants } from "@arobo/styles";
+export type { ComboBoxVariants } from "@arobo/styles";

package/dist/components/combobox/index.js

@@ -0,0 +1,14 @@
+import { ComboBoxRoot, ComboBoxPopover, ComboBoxTrigger, ComboBoxInputGroup } from './combobox.js';
+export { comboboxVariants } from '../../styles/src/components/combobox/combobox.styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const ComboBox = Object.assign(ComboBoxRoot, {
+  Root: ComboBoxRoot,
+  InputGroup: ComboBoxInputGroup,
+  Trigger: ComboBoxTrigger,
+  Popover: ComboBoxPopover
+});
+
+export { ComboBox, ComboBoxInputGroup, ComboBoxPopover, ComboBoxRoot, ComboBoxTrigger };

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

@@ -0,0 +1,9 @@
+import type { DateFieldVariants } from "@arobo/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,28 @@
+import React from 'react';
+import { DateField } from 'react-aria-components';
+import { dataAttr } from '../../utils/assertion.js';
+import { composeTwRenderProps } from '../../utils/compose.js';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { dateFieldVariants } from '../../styles/src/components/date-field/date-field.styles.js';
+
+function DateFieldRoot({
+  children,
+  className,
+  fullWidth,
+  ...props
+}) {
+  const styles = React.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,13 @@
+import type { ComponentProps } from "react";
+import { DateFieldRoot } from "./date-field";
+export declare const DateField: typeof DateFieldRoot & {
+    Root: typeof DateFieldRoot;
+};
+export type DateField = {
+    Props: ComponentProps<typeof DateFieldRoot>;
+    RootProps: ComponentProps<typeof DateFieldRoot>;
+};
+export { DateFieldRoot };
+export type { DateFieldRootProps, DateFieldRootProps as DateFieldProps, } from "./date-field";
+export { dateFieldVariants } from "@arobo/styles";
+export type { DateFieldVariants } from "@arobo/styles";

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

@@ -0,0 +1,11 @@
+import { DateFieldRoot } from './date-field.js';
+export { dateFieldVariants } from '../../styles/src/components/date-field/date-field.styles.js';
+
+/* -------------------------------------------------------------------------------------------------
+ * Compound Component
+ * -----------------------------------------------------------------------------------------------*/
+const DateField = Object.assign(DateFieldRoot, {
+  Root: DateFieldRoot
+});
+
+export { DateField, DateFieldRoot };

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

@@ -0,0 +1,25 @@
+import type { DateInputGroupVariants } from "@arobo/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 { DateInput as DateInputPrimitive, Group as GroupPrimitive } from "react-aria-components";
+interface DateInputGroupRootProps extends ComponentPropsWithRef<typeof GroupPrimitive>, DateInputGroupVariants {
+}
+declare const DateInputGroupRoot: ({ children, className, fullWidth, ...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 DateInputGroupInputCompoundProps extends Omit<ComponentPropsWithRef<typeof DateInputPrimitive>, "children"> {
+}
+declare const DateInputGroupInputCompound: ({ className, ...props }: DateInputGroupInputCompoundProps) => 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, DateInputGroupSegment, DateInputGroupPrefix, DateInputGroupSuffix, DateInputGroupInputCompound, };
+export type { DateInputGroupRootProps, DateInputGroupInputProps, DateInputGroupSegmentProps, DateInputGroupPrefixProps, DateInputGroupSuffixProps, DateInputGroupInputCompoundProps, };