@integration-app/react 2.0.2 → 2.0.3-beta.1

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

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

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

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

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

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

package/dist/types/styled-system/recipes/switch-recipe.d.ts

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

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

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableVariant {
+  /**
+ * @default "plain"
+ */
+variant: "outline" | "plain"
+/**
+ * @default "md"
+ */
+size: "sm" | "md"
+}
+
+type TableVariantMap = {
+  [key in keyof TableVariant]: Array<TableVariant[key]>
+}
+
+export type TableVariantProps = {
+  [key in keyof TableVariant]?: ConditionalValue<TableVariant[key]> | undefined
+}
+
+export interface TableRecipe {
+  __type: TableVariantProps
+  (props?: TableVariantProps): Pretty<Record<"root" | "body" | "cell" | "footer" | "head" | "header" | "row" | "caption", string>>
+  raw: (props?: TableVariantProps) => TableVariantProps
+  variantMap: TableVariantMap
+  variantKeys: Array<keyof TableVariant>
+  splitVariantProps<Props extends TableVariantProps>(props: Props): [TableVariantProps, Pretty<DistributiveOmit<Props, keyof TableVariantProps>>]
+  getVariantProps: (props?: TableVariantProps) => TableVariantProps
+}
+
+
+export declare const table: TableRecipe

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

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TabsVariant {
+  /**
+ * @default "line"
+ */
+variant: "enclosed" | "line" | "outline"
+/**
+ * @default "md"
+ */
+size: "sm" | "md" | "lg"
+}
+
+type TabsVariantMap = {
+  [key in keyof TabsVariant]: Array<TabsVariant[key]>
+}
+
+export type TabsVariantProps = {
+  [key in keyof TabsVariant]?: TabsVariant[key] | undefined
+}
+
+export interface TabsRecipe {
+  __type: TabsVariantProps
+  (props?: TabsVariantProps): Pretty<Record<"root" | "list" | "trigger" | "content" | "indicator", string>>
+  raw: (props?: TabsVariantProps) => TabsVariantProps
+  variantMap: TabsVariantMap
+  variantKeys: Array<keyof TabsVariant>
+  splitVariantProps<Props extends TabsVariantProps>(props: Props): [TabsVariantProps, Pretty<DistributiveOmit<Props, keyof TabsVariantProps>>]
+  getVariantProps: (props?: TabsVariantProps) => TabsVariantProps
+}
+
+
+export declare const tabs: TabsRecipe