@integration-app/react 2.0.3-beta.0 → 2.0.3-beta.2

package/dist/types/styled-system/recipes/editable.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface EditableVariant {
+  
+}
+
+type EditableVariantMap = {
+  [key in keyof EditableVariant]: Array<EditableVariant[key]>
+}
+
+export type EditableVariantProps = {
+  [key in keyof EditableVariant]?: ConditionalValue<EditableVariant[key]> | undefined
+}
+
+export interface EditableRecipe {
+  __type: EditableVariantProps
+  (props?: EditableVariantProps): Pretty<Record<"root" | "area" | "label" | "preview" | "input" | "editTrigger" | "submitTrigger" | "cancelTrigger" | "control", string>>
+  raw: (props?: EditableVariantProps) => EditableVariantProps
+  variantMap: EditableVariantMap
+  variantKeys: Array<keyof EditableVariant>
+  splitVariantProps<Props extends EditableVariantProps>(props: Props): [EditableVariantProps, Pretty<DistributiveOmit<Props, keyof EditableVariantProps>>]
+  getVariantProps: (props?: EditableVariantProps) => EditableVariantProps
+}
+
+
+export declare const editable: EditableRecipe

package/dist/types/styled-system/recipes/field.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FieldVariant {
+  
+}
+
+type FieldVariantMap = {
+  [key in keyof FieldVariant]: Array<FieldVariant[key]>
+}
+
+export type FieldVariantProps = {
+  [key in keyof FieldVariant]?: ConditionalValue<FieldVariant[key]> | undefined
+}
+
+export interface FieldRecipe {
+  __type: FieldVariantProps
+  (props?: FieldVariantProps): Pretty<Record<"root" | "errorText" | "helperText" | "input" | "label" | "select" | "textarea", string>>
+  raw: (props?: FieldVariantProps) => FieldVariantProps
+  variantMap: FieldVariantMap
+  variantKeys: Array<keyof FieldVariant>
+  splitVariantProps<Props extends FieldVariantProps>(props: Props): [FieldVariantProps, Pretty<DistributiveOmit<Props, keyof FieldVariantProps>>]
+  getVariantProps: (props?: FieldVariantProps) => FieldVariantProps
+}
+
+
+export declare const field: FieldRecipe

package/dist/types/styled-system/recipes/fieldset.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FieldsetVariant {
+  
+}
+
+type FieldsetVariantMap = {
+  [key in keyof FieldsetVariant]: Array<FieldsetVariant[key]>
+}
+
+export type FieldsetVariantProps = {
+  [key in keyof FieldsetVariant]?: ConditionalValue<FieldsetVariant[key]> | undefined
+}
+
+export interface FieldsetRecipe {
+  __type: FieldsetVariantProps
+  (props?: FieldsetVariantProps): Pretty<Record<"root" | "errorText" | "helperText" | "legend" | "control", string>>
+  raw: (props?: FieldsetVariantProps) => FieldsetVariantProps
+  variantMap: FieldsetVariantMap
+  variantKeys: Array<keyof FieldsetVariant>
+  splitVariantProps<Props extends FieldsetVariantProps>(props: Props): [FieldsetVariantProps, Pretty<DistributiveOmit<Props, keyof FieldsetVariantProps>>]
+  getVariantProps: (props?: FieldsetVariantProps) => FieldsetVariantProps
+}
+
+
+export declare const fieldset: FieldsetRecipe

package/dist/types/styled-system/recipes/file-upload.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FileUploadVariant {
+  
+}
+
+type FileUploadVariantMap = {
+  [key in keyof FileUploadVariant]: Array<FileUploadVariant[key]>
+}
+
+export type FileUploadVariantProps = {
+  [key in keyof FileUploadVariant]?: ConditionalValue<FileUploadVariant[key]> | undefined
+}
+
+export interface FileUploadRecipe {
+  __type: FileUploadVariantProps
+  (props?: FileUploadVariantProps): Pretty<Record<"root" | "dropzone" | "item" | "itemDeleteTrigger" | "itemGroup" | "itemName" | "itemPreview" | "itemPreviewImage" | "itemSizeText" | "label" | "trigger", string>>
+  raw: (props?: FileUploadVariantProps) => FileUploadVariantProps
+  variantMap: FileUploadVariantMap
+  variantKeys: Array<keyof FileUploadVariant>
+  splitVariantProps<Props extends FileUploadVariantProps>(props: Props): [FileUploadVariantProps, Pretty<DistributiveOmit<Props, keyof FileUploadVariantProps>>]
+  getVariantProps: (props?: FileUploadVariantProps) => FileUploadVariantProps
+}
+
+
+export declare const fileUpload: FileUploadRecipe

package/dist/types/styled-system/recipes/form-label.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FormLabelVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg" | "xl"
+}
+
+type FormLabelVariantMap = {
+  [key in keyof FormLabelVariant]: Array<FormLabelVariant[key]>
+}
+
+export type FormLabelVariantProps = {
+  [key in keyof FormLabelVariant]?: ConditionalValue<FormLabelVariant[key]> | undefined
+}
+
+export interface FormLabelRecipe {
+  __type: FormLabelVariantProps
+  (props?: FormLabelVariantProps): string
+  raw: (props?: FormLabelVariantProps) => FormLabelVariantProps
+  variantMap: FormLabelVariantMap
+  variantKeys: Array<keyof FormLabelVariant>
+  splitVariantProps<Props extends FormLabelVariantProps>(props: Props): [FormLabelVariantProps, Pretty<DistributiveOmit<Props, keyof FormLabelVariantProps>>]
+  getVariantProps: (props?: FormLabelVariantProps) => FormLabelVariantProps
+}
+
+
+export declare const formLabel: FormLabelRecipe

package/dist/types/styled-system/recipes/hover-card.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface HoverCardVariant {
+  
+}
+
+type HoverCardVariantMap = {
+  [key in keyof HoverCardVariant]: Array<HoverCardVariant[key]>
+}
+
+export type HoverCardVariantProps = {
+  [key in keyof HoverCardVariant]?: ConditionalValue<HoverCardVariant[key]> | undefined
+}
+
+export interface HoverCardRecipe {
+  __type: HoverCardVariantProps
+  (props?: HoverCardVariantProps): Pretty<Record<"arrow" | "arrowTip" | "trigger" | "positioner" | "content", string>>
+  raw: (props?: HoverCardVariantProps) => HoverCardVariantProps
+  variantMap: HoverCardVariantMap
+  variantKeys: Array<keyof HoverCardVariant>
+  splitVariantProps<Props extends HoverCardVariantProps>(props: Props): [HoverCardVariantProps, Pretty<DistributiveOmit<Props, keyof HoverCardVariantProps>>]
+  getVariantProps: (props?: HoverCardVariantProps) => HoverCardVariantProps
+}
+
+
+export declare const hoverCard: HoverCardRecipe

package/dist/types/styled-system/recipes/icon.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface IconVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type IconVariantMap = {
+  [key in keyof IconVariant]: Array<IconVariant[key]>
+}
+
+export type IconVariantProps = {
+  [key in keyof IconVariant]?: ConditionalValue<IconVariant[key]> | undefined
+}
+
+export interface IconRecipe {
+  __type: IconVariantProps
+  (props?: IconVariantProps): string
+  raw: (props?: IconVariantProps) => IconVariantProps
+  variantMap: IconVariantMap
+  variantKeys: Array<keyof IconVariant>
+  splitVariantProps<Props extends IconVariantProps>(props: Props): [IconVariantProps, Pretty<DistributiveOmit<Props, keyof IconVariantProps>>]
+  getVariantProps: (props?: IconVariantProps) => IconVariantProps
+}
+
+
+export declare const icon: IconRecipe

package/dist/types/styled-system/recipes/index.d.ts

@@ -0,0 +1,54 @@
+/* eslint-disable */
+export * from './badge';
+export * from './button';
+export * from './code';
+export * from './form-label';
+export * from './icon';
+export * from './input';
+export * from './kbd';
+export * from './link';
+export * from './skeleton';
+export * from './spinner';
+export * from './textarea';
+export * from './text';
+export * from './accordion';
+export * from './alert';
+export * from './avatar';
+export * from './card';
+export * from './carousel';
+export * from './checkbox';
+export * from './clipboard';
+export * from './collapsible';
+export * from './color-picker';
+export * from './combobox';
+export * from './date-picker';
+export * from './dialog';
+export * from './drawer';
+export * from './editable';
+export * from './field';
+export * from './fieldset';
+export * from './file-upload';
+export * from './hover-card';
+export * from './menu';
+export * from './number-input';
+export * from './pagination';
+export * from './pin-input';
+export * from './popover';
+export * from './progress';
+export * from './radio-button-group';
+export * from './radio-group';
+export * from './rating-group';
+export * from './segment-group';
+export * from './select';
+export * from './signature-pad';
+export * from './slider';
+export * from './splitter';
+export * from './switch-recipe';
+export * from './table';
+export * from './tabs';
+export * from './tags-input';
+export * from './toast';
+export * from './toggle-group';
+export * from './tooltip';
+export * from './tree-view';
+export * from './qr-code';

package/dist/types/styled-system/recipes/input.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface InputVariant {
+  /**
+ * @default "md"
+ */
+size: "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type InputVariantMap = {
+  [key in keyof InputVariant]: Array<InputVariant[key]>
+}
+
+export type InputVariantProps = {
+  [key in keyof InputVariant]?: ConditionalValue<InputVariant[key]> | undefined
+}
+
+export interface InputRecipe {
+  __type: InputVariantProps
+  (props?: InputVariantProps): string
+  raw: (props?: InputVariantProps) => InputVariantProps
+  variantMap: InputVariantMap
+  variantKeys: Array<keyof InputVariant>
+  splitVariantProps<Props extends InputVariantProps>(props: Props): [InputVariantProps, Pretty<DistributiveOmit<Props, keyof InputVariantProps>>]
+  getVariantProps: (props?: InputVariantProps) => InputVariantProps
+}
+
+
+export declare const input: InputRecipe

package/dist/types/styled-system/recipes/kbd.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface KbdVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type KbdVariantMap = {
+  [key in keyof KbdVariant]: Array<KbdVariant[key]>
+}
+
+export type KbdVariantProps = {
+  [key in keyof KbdVariant]?: ConditionalValue<KbdVariant[key]> | undefined
+}
+
+export interface KbdRecipe {
+  __type: KbdVariantProps
+  (props?: KbdVariantProps): string
+  raw: (props?: KbdVariantProps) => KbdVariantProps
+  variantMap: KbdVariantMap
+  variantKeys: Array<keyof KbdVariant>
+  splitVariantProps<Props extends KbdVariantProps>(props: Props): [KbdVariantProps, Pretty<DistributiveOmit<Props, keyof KbdVariantProps>>]
+  getVariantProps: (props?: KbdVariantProps) => KbdVariantProps
+}
+
+
+export declare const kbd: KbdRecipe

package/dist/types/styled-system/recipes/link.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface LinkVariant {
+  
+}
+
+type LinkVariantMap = {
+  [key in keyof LinkVariant]: Array<LinkVariant[key]>
+}
+
+export type LinkVariantProps = {
+  [key in keyof LinkVariant]?: ConditionalValue<LinkVariant[key]> | undefined
+}
+
+export interface LinkRecipe {
+  __type: LinkVariantProps
+  (props?: LinkVariantProps): string
+  raw: (props?: LinkVariantProps) => LinkVariantProps
+  variantMap: LinkVariantMap
+  variantKeys: Array<keyof LinkVariant>
+  splitVariantProps<Props extends LinkVariantProps>(props: Props): [LinkVariantProps, Pretty<DistributiveOmit<Props, keyof LinkVariantProps>>]
+  getVariantProps: (props?: LinkVariantProps) => LinkVariantProps
+}
+
+
+export declare const link: LinkRecipe

package/dist/types/styled-system/recipes/menu.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MenuVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg"
+}
+
+type MenuVariantMap = {
+  [key in keyof MenuVariant]: Array<MenuVariant[key]>
+}
+
+export type MenuVariantProps = {
+  [key in keyof MenuVariant]?: ConditionalValue<MenuVariant[key]> | undefined
+}
+
+export interface MenuRecipe {
+  __type: MenuVariantProps
+  (props?: MenuVariantProps): Pretty<Record<"arrow" | "arrowTip" | "content" | "contextTrigger" | "indicator" | "item" | "itemGroup" | "itemGroupLabel" | "itemIndicator" | "itemText" | "positioner" | "separator" | "trigger" | "triggerItem", string>>
+  raw: (props?: MenuVariantProps) => MenuVariantProps
+  variantMap: MenuVariantMap
+  variantKeys: Array<keyof MenuVariant>
+  splitVariantProps<Props extends MenuVariantProps>(props: Props): [MenuVariantProps, Pretty<DistributiveOmit<Props, keyof MenuVariantProps>>]
+  getVariantProps: (props?: MenuVariantProps) => MenuVariantProps
+}
+
+
+export declare const menu: MenuRecipe

package/dist/types/styled-system/recipes/number-input.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface NumberInputVariant {
+  /**
+ * @default "md"
+ */
+size: "md" | "lg" | "xl"
+}
+
+type NumberInputVariantMap = {
+  [key in keyof NumberInputVariant]: Array<NumberInputVariant[key]>
+}
+
+export type NumberInputVariantProps = {
+  [key in keyof NumberInputVariant]?: ConditionalValue<NumberInputVariant[key]> | undefined
+}
+
+export interface NumberInputRecipe {
+  __type: NumberInputVariantProps
+  (props?: NumberInputVariantProps): Pretty<Record<"root" | "label" | "input" | "control" | "valueText" | "incrementTrigger" | "decrementTrigger" | "scrubber", string>>
+  raw: (props?: NumberInputVariantProps) => NumberInputVariantProps
+  variantMap: NumberInputVariantMap
+  variantKeys: Array<keyof NumberInputVariant>
+  splitVariantProps<Props extends NumberInputVariantProps>(props: Props): [NumberInputVariantProps, Pretty<DistributiveOmit<Props, keyof NumberInputVariantProps>>]
+  getVariantProps: (props?: NumberInputVariantProps) => NumberInputVariantProps
+}
+
+
+export declare const numberInput: NumberInputRecipe

package/dist/types/styled-system/recipes/pagination.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PaginationVariant {
+  
+}
+
+type PaginationVariantMap = {
+  [key in keyof PaginationVariant]: Array<PaginationVariant[key]>
+}
+
+export type PaginationVariantProps = {
+  [key in keyof PaginationVariant]?: ConditionalValue<PaginationVariant[key]> | undefined
+}
+
+export interface PaginationRecipe {
+  __type: PaginationVariantProps
+  (props?: PaginationVariantProps): Pretty<Record<"root" | "item" | "ellipsis" | "prevTrigger" | "nextTrigger", string>>
+  raw: (props?: PaginationVariantProps) => PaginationVariantProps
+  variantMap: PaginationVariantMap
+  variantKeys: Array<keyof PaginationVariant>
+  splitVariantProps<Props extends PaginationVariantProps>(props: Props): [PaginationVariantProps, Pretty<DistributiveOmit<Props, keyof PaginationVariantProps>>]
+  getVariantProps: (props?: PaginationVariantProps) => PaginationVariantProps
+}
+
+
+export declare const pagination: PaginationRecipe

package/dist/types/styled-system/recipes/pin-input.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PinInputVariant {
+  /**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type PinInputVariantMap = {
+  [key in keyof PinInputVariant]: Array<PinInputVariant[key]>
+}
+
+export type PinInputVariantProps = {
+  [key in keyof PinInputVariant]?: ConditionalValue<PinInputVariant[key]> | undefined
+}
+
+export interface PinInputRecipe {
+  __type: PinInputVariantProps
+  (props?: PinInputVariantProps): Pretty<Record<"root" | "label" | "input" | "control", string>>
+  raw: (props?: PinInputVariantProps) => PinInputVariantProps
+  variantMap: PinInputVariantMap
+  variantKeys: Array<keyof PinInputVariant>
+  splitVariantProps<Props extends PinInputVariantProps>(props: Props): [PinInputVariantProps, Pretty<DistributiveOmit<Props, keyof PinInputVariantProps>>]
+  getVariantProps: (props?: PinInputVariantProps) => PinInputVariantProps
+}
+
+
+export declare const pinInput: PinInputRecipe

package/dist/types/styled-system/recipes/popover.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PopoverVariant {
+  
+}
+
+type PopoverVariantMap = {
+  [key in keyof PopoverVariant]: Array<PopoverVariant[key]>
+}
+
+export type PopoverVariantProps = {
+  [key in keyof PopoverVariant]?: ConditionalValue<PopoverVariant[key]> | undefined
+}
+
+export interface PopoverRecipe {
+  __type: PopoverVariantProps
+  (props?: PopoverVariantProps): Pretty<Record<"arrow" | "arrowTip" | "anchor" | "trigger" | "indicator" | "positioner" | "content" | "title" | "description" | "closeTrigger", string>>
+  raw: (props?: PopoverVariantProps) => PopoverVariantProps
+  variantMap: PopoverVariantMap
+  variantKeys: Array<keyof PopoverVariant>
+  splitVariantProps<Props extends PopoverVariantProps>(props: Props): [PopoverVariantProps, Pretty<DistributiveOmit<Props, keyof PopoverVariantProps>>]
+  getVariantProps: (props?: PopoverVariantProps) => PopoverVariantProps
+}
+
+
+export declare const popover: PopoverRecipe

package/dist/types/styled-system/recipes/progress.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ProgressVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type ProgressVariantMap = {
+  [key in keyof ProgressVariant]: Array<ProgressVariant[key]>
+}
+
+export type ProgressVariantProps = {
+  [key in keyof ProgressVariant]?: ConditionalValue<ProgressVariant[key]> | undefined
+}
+
+export interface ProgressRecipe {
+  __type: ProgressVariantProps
+  (props?: ProgressVariantProps): Pretty<Record<"root" | "label" | "track" | "range" | "valueText" | "view" | "circle" | "circleTrack" | "circleRange", string>>
+  raw: (props?: ProgressVariantProps) => ProgressVariantProps
+  variantMap: ProgressVariantMap
+  variantKeys: Array<keyof ProgressVariant>
+  splitVariantProps<Props extends ProgressVariantProps>(props: Props): [ProgressVariantProps, Pretty<DistributiveOmit<Props, keyof ProgressVariantProps>>]
+  getVariantProps: (props?: ProgressVariantProps) => ProgressVariantProps
+}
+
+
+export declare const progress: ProgressRecipe

package/dist/types/styled-system/recipes/qr-code.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface QrCodeVariant {
+  
+}
+
+type QrCodeVariantMap = {
+  [key in keyof QrCodeVariant]: Array<QrCodeVariant[key]>
+}
+
+export type QrCodeVariantProps = {
+  [key in keyof QrCodeVariant]?: ConditionalValue<QrCodeVariant[key]> | undefined
+}
+
+export interface QrCodeRecipe {
+  __type: QrCodeVariantProps
+  (props?: QrCodeVariantProps): Pretty<Record<"root" | "frame" | "pattern" | "overlay", string>>
+  raw: (props?: QrCodeVariantProps) => QrCodeVariantProps
+  variantMap: QrCodeVariantMap
+  variantKeys: Array<keyof QrCodeVariant>
+  splitVariantProps<Props extends QrCodeVariantProps>(props: Props): [QrCodeVariantProps, Pretty<DistributiveOmit<Props, keyof QrCodeVariantProps>>]
+  getVariantProps: (props?: QrCodeVariantProps) => QrCodeVariantProps
+}
+
+
+export declare const qrCode: QrCodeRecipe

package/dist/types/styled-system/recipes/radio-button-group.d.ts

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface RadioButtonGroupVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid" | "outline"
+/**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg" | "xl"
+}
+
+type RadioButtonGroupVariantMap = {
+  [key in keyof RadioButtonGroupVariant]: Array<RadioButtonGroupVariant[key]>
+}
+
+export type RadioButtonGroupVariantProps = {
+  [key in keyof RadioButtonGroupVariant]?: ConditionalValue<RadioButtonGroupVariant[key]> | undefined
+}
+
+export interface RadioButtonGroupRecipe {
+  __type: RadioButtonGroupVariantProps
+  (props?: RadioButtonGroupVariantProps): Pretty<Record<"root" | "label" | "item" | "itemText" | "itemControl" | "indicator", string>>
+  raw: (props?: RadioButtonGroupVariantProps) => RadioButtonGroupVariantProps
+  variantMap: RadioButtonGroupVariantMap
+  variantKeys: Array<keyof RadioButtonGroupVariant>
+  splitVariantProps<Props extends RadioButtonGroupVariantProps>(props: Props): [RadioButtonGroupVariantProps, Pretty<DistributiveOmit<Props, keyof RadioButtonGroupVariantProps>>]
+  getVariantProps: (props?: RadioButtonGroupVariantProps) => RadioButtonGroupVariantProps
+}
+
+
+export declare const radioButtonGroup: RadioButtonGroupRecipe

package/dist/types/styled-system/recipes/radio-group.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface RadioGroupVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type RadioGroupVariantMap = {
+  [key in keyof RadioGroupVariant]: Array<RadioGroupVariant[key]>
+}
+
+export type RadioGroupVariantProps = {
+  [key in keyof RadioGroupVariant]?: ConditionalValue<RadioGroupVariant[key]> | undefined
+}
+
+export interface RadioGroupRecipe {
+  __type: RadioGroupVariantProps
+  (props?: RadioGroupVariantProps): Pretty<Record<"root" | "label" | "item" | "itemText" | "itemControl" | "indicator", string>>
+  raw: (props?: RadioGroupVariantProps) => RadioGroupVariantProps
+  variantMap: RadioGroupVariantMap
+  variantKeys: Array<keyof RadioGroupVariant>
+  splitVariantProps<Props extends RadioGroupVariantProps>(props: Props): [RadioGroupVariantProps, Pretty<DistributiveOmit<Props, keyof RadioGroupVariantProps>>]
+  getVariantProps: (props?: RadioGroupVariantProps) => RadioGroupVariantProps
+}
+
+
+export declare const radioGroup: RadioGroupRecipe