@membranehq/react 0.1.0

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AlertVariant {
+  
+}
+
+type AlertVariantMap = {
+  [key in keyof AlertVariant]: Array<AlertVariant[key]>
+}
+
+export type AlertVariantProps = {
+  [key in keyof AlertVariant]?: ConditionalValue<AlertVariant[key]> | undefined
+}
+
+export interface AlertRecipe {
+  __type: AlertVariantProps
+  (props?: AlertVariantProps): Pretty<Record<"root" | "content" | "description" | "icon" | "title", string>>
+  raw: (props?: AlertVariantProps) => AlertVariantProps
+  variantMap: AlertVariantMap
+  variantKeys: Array<keyof AlertVariant>
+  splitVariantProps<Props extends AlertVariantProps>(props: Props): [AlertVariantProps, Pretty<DistributiveOmit<Props, keyof AlertVariantProps>>]
+  getVariantProps: (props?: AlertVariantProps) => AlertVariantProps
+}
+
+
+export declare const alert: AlertRecipe

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

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

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

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface BadgeVariant {
+  /**
+ * @default "subtle"
+ */
+variant: "solid" | "subtle" | "outline"
+/**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type BadgeVariantMap = {
+  [key in keyof BadgeVariant]: Array<BadgeVariant[key]>
+}
+
+export type BadgeVariantProps = {
+  [key in keyof BadgeVariant]?: ConditionalValue<BadgeVariant[key]> | undefined
+}
+
+export interface BadgeRecipe {
+  __type: BadgeVariantProps
+  (props?: BadgeVariantProps): string
+  raw: (props?: BadgeVariantProps) => BadgeVariantProps
+  variantMap: BadgeVariantMap
+  variantKeys: Array<keyof BadgeVariant>
+  splitVariantProps<Props extends BadgeVariantProps>(props: Props): [BadgeVariantProps, Pretty<DistributiveOmit<Props, keyof BadgeVariantProps>>]
+  getVariantProps: (props?: BadgeVariantProps) => BadgeVariantProps
+}
+
+
+export declare const badge: BadgeRecipe

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

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ButtonVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid" | "outline" | "ghost" | "link" | "subtle"
+/**
+ * @default "md"
+ */
+size: "xs" | "sm" | "md" | "lg" | "xl" | "2xl"
+}
+
+type ButtonVariantMap = {
+  [key in keyof ButtonVariant]: Array<ButtonVariant[key]>
+}
+
+export type ButtonVariantProps = {
+  [key in keyof ButtonVariant]?: ConditionalValue<ButtonVariant[key]> | undefined
+}
+
+export interface ButtonRecipe {
+  __type: ButtonVariantProps
+  (props?: ButtonVariantProps): string
+  raw: (props?: ButtonVariantProps) => ButtonVariantProps
+  variantMap: ButtonVariantMap
+  variantKeys: Array<keyof ButtonVariant>
+  splitVariantProps<Props extends ButtonVariantProps>(props: Props): [ButtonVariantProps, Pretty<DistributiveOmit<Props, keyof ButtonVariantProps>>]
+  getVariantProps: (props?: ButtonVariantProps) => ButtonVariantProps
+}
+
+
+export declare const button: ButtonRecipe

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CardVariant {
+  
+}
+
+type CardVariantMap = {
+  [key in keyof CardVariant]: Array<CardVariant[key]>
+}
+
+export type CardVariantProps = {
+  [key in keyof CardVariant]?: ConditionalValue<CardVariant[key]> | undefined
+}
+
+export interface CardRecipe {
+  __type: CardVariantProps
+  (props?: CardVariantProps): Pretty<Record<"root" | "header" | "body" | "footer" | "title" | "description", string>>
+  raw: (props?: CardVariantProps) => CardVariantProps
+  variantMap: CardVariantMap
+  variantKeys: Array<keyof CardVariant>
+  splitVariantProps<Props extends CardVariantProps>(props: Props): [CardVariantProps, Pretty<DistributiveOmit<Props, keyof CardVariantProps>>]
+  getVariantProps: (props?: CardVariantProps) => CardVariantProps
+}
+
+
+export declare const card: CardRecipe

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CarouselVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md"
+}
+
+type CarouselVariantMap = {
+  [key in keyof CarouselVariant]: Array<CarouselVariant[key]>
+}
+
+export type CarouselVariantProps = {
+  [key in keyof CarouselVariant]?: ConditionalValue<CarouselVariant[key]> | undefined
+}
+
+export interface CarouselRecipe {
+  __type: CarouselVariantProps
+  (props?: CarouselVariantProps): Pretty<Record<"root" | "itemGroup" | "item" | "control" | "nextTrigger" | "prevTrigger" | "indicatorGroup" | "indicator" | "autoplayTrigger", string>>
+  raw: (props?: CarouselVariantProps) => CarouselVariantProps
+  variantMap: CarouselVariantMap
+  variantKeys: Array<keyof CarouselVariant>
+  splitVariantProps<Props extends CarouselVariantProps>(props: Props): [CarouselVariantProps, Pretty<DistributiveOmit<Props, keyof CarouselVariantProps>>]
+  getVariantProps: (props?: CarouselVariantProps) => CarouselVariantProps
+}
+
+
+export declare const carousel: CarouselRecipe

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

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

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ClipboardVariant {
+  
+}
+
+type ClipboardVariantMap = {
+  [key in keyof ClipboardVariant]: Array<ClipboardVariant[key]>
+}
+
+export type ClipboardVariantProps = {
+  [key in keyof ClipboardVariant]?: ConditionalValue<ClipboardVariant[key]> | undefined
+}
+
+export interface ClipboardRecipe {
+  __type: ClipboardVariantProps
+  (props?: ClipboardVariantProps): Pretty<Record<"root" | "control" | "trigger" | "indicator" | "input" | "label", string>>
+  raw: (props?: ClipboardVariantProps) => ClipboardVariantProps
+  variantMap: ClipboardVariantMap
+  variantKeys: Array<keyof ClipboardVariant>
+  splitVariantProps<Props extends ClipboardVariantProps>(props: Props): [ClipboardVariantProps, Pretty<DistributiveOmit<Props, keyof ClipboardVariantProps>>]
+  getVariantProps: (props?: ClipboardVariantProps) => ClipboardVariantProps
+}
+
+
+export declare const clipboard: ClipboardRecipe

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

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface CodeVariant {
+  /**
+ * @default "outline"
+ */
+variant: "outline" | "ghost"
+/**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type CodeVariantMap = {
+  [key in keyof CodeVariant]: Array<CodeVariant[key]>
+}
+
+export type CodeVariantProps = {
+  [key in keyof CodeVariant]?: ConditionalValue<CodeVariant[key]> | undefined
+}
+
+export interface CodeRecipe {
+  __type: CodeVariantProps
+  (props?: CodeVariantProps): string
+  raw: (props?: CodeVariantProps) => CodeVariantProps
+  variantMap: CodeVariantMap
+  variantKeys: Array<keyof CodeVariant>
+  splitVariantProps<Props extends CodeVariantProps>(props: Props): [CodeVariantProps, Pretty<DistributiveOmit<Props, keyof CodeVariantProps>>]
+  getVariantProps: (props?: CodeVariantProps) => CodeVariantProps
+}
+
+
+export declare const code: CodeRecipe

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

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

package/dist/types/styled-system/recipes/color-picker.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ColorPickerVariant {
+  
+}
+
+type ColorPickerVariantMap = {
+  [key in keyof ColorPickerVariant]: Array<ColorPickerVariant[key]>
+}
+
+export type ColorPickerVariantProps = {
+  [key in keyof ColorPickerVariant]?: ConditionalValue<ColorPickerVariant[key]> | undefined
+}
+
+export interface ColorPickerRecipe {
+  __type: ColorPickerVariantProps
+  (props?: ColorPickerVariantProps): Pretty<Record<"root" | "label" | "control" | "trigger" | "positioner" | "content" | "area" | "areaThumb" | "valueText" | "areaBackground" | "channelSlider" | "channelSliderLabel" | "channelSliderTrack" | "channelSliderThumb" | "channelSliderValueText" | "channelInput" | "transparencyGrid" | "swatchGroup" | "swatchTrigger" | "swatchIndicator" | "swatch" | "eyeDropperTrigger" | "formatTrigger" | "formatSelect" | "view", string>>
+  raw: (props?: ColorPickerVariantProps) => ColorPickerVariantProps
+  variantMap: ColorPickerVariantMap
+  variantKeys: Array<keyof ColorPickerVariant>
+  splitVariantProps<Props extends ColorPickerVariantProps>(props: Props): [ColorPickerVariantProps, Pretty<DistributiveOmit<Props, keyof ColorPickerVariantProps>>]
+  getVariantProps: (props?: ColorPickerVariantProps) => ColorPickerVariantProps
+}
+
+
+export declare const colorPicker: ColorPickerRecipe

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface ComboboxVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type ComboboxVariantMap = {
+  [key in keyof ComboboxVariant]: Array<ComboboxVariant[key]>
+}
+
+export type ComboboxVariantProps = {
+  [key in keyof ComboboxVariant]?: ConditionalValue<ComboboxVariant[key]> | undefined
+}
+
+export interface ComboboxRecipe {
+  __type: ComboboxVariantProps
+  (props?: ComboboxVariantProps): Pretty<Record<"root" | "clearTrigger" | "content" | "control" | "input" | "item" | "itemGroup" | "itemGroupLabel" | "itemIndicator" | "itemText" | "label" | "list" | "positioner" | "trigger", string>>
+  raw: (props?: ComboboxVariantProps) => ComboboxVariantProps
+  variantMap: ComboboxVariantMap
+  variantKeys: Array<keyof ComboboxVariant>
+  splitVariantProps<Props extends ComboboxVariantProps>(props: Props): [ComboboxVariantProps, Pretty<DistributiveOmit<Props, keyof ComboboxVariantProps>>]
+  getVariantProps: (props?: ComboboxVariantProps) => ComboboxVariantProps
+}
+
+
+export declare const combobox: ComboboxRecipe

package/dist/types/styled-system/recipes/date-picker.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DatePickerVariant {
+  
+}
+
+type DatePickerVariantMap = {
+  [key in keyof DatePickerVariant]: Array<DatePickerVariant[key]>
+}
+
+export type DatePickerVariantProps = {
+  [key in keyof DatePickerVariant]?: ConditionalValue<DatePickerVariant[key]> | undefined
+}
+
+export interface DatePickerRecipe {
+  __type: DatePickerVariantProps
+  (props?: DatePickerVariantProps): Pretty<Record<"root" | "label" | "clearTrigger" | "content" | "control" | "input" | "monthSelect" | "nextTrigger" | "positioner" | "prevTrigger" | "rangeText" | "table" | "tableBody" | "tableCell" | "tableCellTrigger" | "tableHead" | "tableHeader" | "tableRow" | "trigger" | "viewTrigger" | "viewControl" | "yearSelect" | "presetTrigger" | "view", string>>
+  raw: (props?: DatePickerVariantProps) => DatePickerVariantProps
+  variantMap: DatePickerVariantMap
+  variantKeys: Array<keyof DatePickerVariant>
+  splitVariantProps<Props extends DatePickerVariantProps>(props: Props): [DatePickerVariantProps, Pretty<DistributiveOmit<Props, keyof DatePickerVariantProps>>]
+  getVariantProps: (props?: DatePickerVariantProps) => DatePickerVariantProps
+}
+
+
+export declare const datePicker: DatePickerRecipe

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

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

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DrawerVariant {
+  /**
+ * @default "right"
+ */
+variant: "left" | "right"
+}
+
+type DrawerVariantMap = {
+  [key in keyof DrawerVariant]: Array<DrawerVariant[key]>
+}
+
+export type DrawerVariantProps = {
+  [key in keyof DrawerVariant]?: ConditionalValue<DrawerVariant[key]> | undefined
+}
+
+export interface DrawerRecipe {
+  __type: DrawerVariantProps
+  (props?: DrawerVariantProps): Pretty<Record<"trigger" | "backdrop" | "positioner" | "content" | "title" | "description" | "closeTrigger" | "header" | "body" | "footer", string>>
+  raw: (props?: DrawerVariantProps) => DrawerVariantProps
+  variantMap: DrawerVariantMap
+  variantKeys: Array<keyof DrawerVariant>
+  splitVariantProps<Props extends DrawerVariantProps>(props: Props): [DrawerVariantProps, Pretty<DistributiveOmit<Props, keyof DrawerVariantProps>>]
+  getVariantProps: (props?: DrawerVariantProps) => DrawerVariantProps
+}
+
+
+export declare const drawer: DrawerRecipe

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" | "requiredIndicator", 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" | "clearTrigger", 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