@membranehq/react 0.1.0

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" | "downloadTrigger", 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

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

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

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

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

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

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

package/dist/types/styled-system/recipes/signature-pad.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SignaturePadVariant {
+  
+}
+
+type SignaturePadVariantMap = {
+  [key in keyof SignaturePadVariant]: Array<SignaturePadVariant[key]>
+}
+
+export type SignaturePadVariantProps = {
+  [key in keyof SignaturePadVariant]?: ConditionalValue<SignaturePadVariant[key]> | undefined
+}
+
+export interface SignaturePadRecipe {
+  __type: SignaturePadVariantProps
+  (props?: SignaturePadVariantProps): Pretty<Record<"root" | "control" | "segment" | "segmentPath" | "guide" | "clearTrigger" | "label", string>>
+  raw: (props?: SignaturePadVariantProps) => SignaturePadVariantProps
+  variantMap: SignaturePadVariantMap
+  variantKeys: Array<keyof SignaturePadVariant>
+  splitVariantProps<Props extends SignaturePadVariantProps>(props: Props): [SignaturePadVariantProps, Pretty<DistributiveOmit<Props, keyof SignaturePadVariantProps>>]
+  getVariantProps: (props?: SignaturePadVariantProps) => SignaturePadVariantProps
+}
+
+
+export declare const signaturePad: SignaturePadRecipe

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

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

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SliderVariant {
+  /**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type SliderVariantMap = {
+  [key in keyof SliderVariant]: Array<SliderVariant[key]>
+}
+
+export type SliderVariantProps = {
+  [key in keyof SliderVariant]?: ConditionalValue<SliderVariant[key]> | undefined
+}
+
+export interface SliderRecipe {
+  __type: SliderVariantProps
+  (props?: SliderVariantProps): Pretty<Record<"root" | "label" | "thumb" | "valueText" | "track" | "range" | "control" | "markerGroup" | "marker" | "draggingIndicator", string>>
+  raw: (props?: SliderVariantProps) => SliderVariantProps
+  variantMap: SliderVariantMap
+  variantKeys: Array<keyof SliderVariant>
+  splitVariantProps<Props extends SliderVariantProps>(props: Props): [SliderVariantProps, Pretty<DistributiveOmit<Props, keyof SliderVariantProps>>]
+  getVariantProps: (props?: SliderVariantProps) => SliderVariantProps
+}
+
+
+export declare const slider: SliderRecipe