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

package/dist/types/styled-system/patterns/spacer.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface SpacerProperties {
+   size?: ConditionalValue<Tokens["spacing"]>
+}
+
+
+interface SpacerStyles extends SpacerProperties, DistributiveOmit<SystemStyleObject, keyof SpacerProperties > {}
+
+interface SpacerPatternFn {
+  (styles?: SpacerStyles): string
+  raw: (styles?: SpacerStyles) => SystemStyleObject
+}
+
+
+export declare const spacer: SpacerPatternFn;

package/dist/types/styled-system/patterns/square.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface SquareProperties {
+   size?: SystemProperties["width"]
+}
+
+
+interface SquareStyles extends SquareProperties, DistributiveOmit<SystemStyleObject, keyof SquareProperties > {}
+
+interface SquarePatternFn {
+  (styles?: SquareStyles): string
+  raw: (styles?: SquareStyles) => SystemStyleObject
+}
+
+
+export declare const square: SquarePatternFn;

package/dist/types/styled-system/patterns/stack.d.ts

@@ -0,0 +1,24 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface StackProperties {
+   align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+	direction?: SystemProperties["flexDirection"]
+	gap?: SystemProperties["gap"]
+}
+
+
+interface StackStyles extends StackProperties, DistributiveOmit<SystemStyleObject, keyof StackProperties > {}
+
+interface StackPatternFn {
+  (styles?: StackStyles): string
+  raw: (styles?: StackStyles) => SystemStyleObject
+}
+
+
+export declare const stack: StackPatternFn;

package/dist/types/styled-system/patterns/visually-hidden.d.ts

@@ -0,0 +1,21 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface VisuallyHiddenProperties {
+   
+}
+
+
+interface VisuallyHiddenStyles extends VisuallyHiddenProperties, DistributiveOmit<SystemStyleObject, keyof VisuallyHiddenProperties > {}
+
+interface VisuallyHiddenPatternFn {
+  (styles?: VisuallyHiddenStyles): string
+  raw: (styles?: VisuallyHiddenStyles) => SystemStyleObject
+}
+
+
+export declare const visuallyHidden: VisuallyHiddenPatternFn;

package/dist/types/styled-system/patterns/vstack.d.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface VstackProperties {
+   justify?: SystemProperties["justifyContent"]
+	gap?: SystemProperties["gap"]
+}
+
+
+interface VstackStyles extends VstackProperties, DistributiveOmit<SystemStyleObject, keyof VstackProperties > {}
+
+interface VstackPatternFn {
+  (styles?: VstackStyles): string
+  raw: (styles?: VstackStyles) => SystemStyleObject
+}
+
+
+export declare const vstack: VstackPatternFn;

package/dist/types/styled-system/patterns/wrap.d.ts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+import type { SystemStyleObject, ConditionalValue } from '../types/index';
+import type { Properties } from '../types/csstype';
+import type { SystemProperties } from '../types/style-props';
+import type { DistributiveOmit } from '../types/system-types';
+import type { Tokens } from '../tokens/index';
+
+export interface WrapProperties {
+   gap?: SystemProperties["gap"]
+	rowGap?: SystemProperties["gap"]
+	columnGap?: SystemProperties["gap"]
+	align?: SystemProperties["alignItems"]
+	justify?: SystemProperties["justifyContent"]
+}
+
+
+interface WrapStyles extends WrapProperties, DistributiveOmit<SystemStyleObject, keyof WrapProperties > {}
+
+interface WrapPatternFn {
+  (styles?: WrapStyles): string
+  raw: (styles?: WrapStyles) => SystemStyleObject
+}
+
+
+export declare const wrap: WrapPatternFn;

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

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AccordionVariant {
+  /**
+ * @default "md"
+ */
+size: "md"
+}
+
+type AccordionVariantMap = {
+  [key in keyof AccordionVariant]: Array<AccordionVariant[key]>
+}
+
+export type AccordionVariantProps = {
+  [key in keyof AccordionVariant]?: ConditionalValue<AccordionVariant[key]> | undefined
+}
+
+export interface AccordionRecipe {
+  __type: AccordionVariantProps
+  (props?: AccordionVariantProps): Pretty<Record<"root" | "item" | "itemTrigger" | "itemContent" | "itemIndicator", string>>
+  raw: (props?: AccordionVariantProps) => AccordionVariantProps
+  variantMap: AccordionVariantMap
+  variantKeys: Array<keyof AccordionVariant>
+  splitVariantProps<Props extends AccordionVariantProps>(props: Props): [AccordionVariantProps, Pretty<DistributiveOmit<Props, keyof AccordionVariantProps>>]
+  getVariantProps: (props?: AccordionVariantProps) => AccordionVariantProps
+}
+
+
+export declare const accordion: AccordionRecipe

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" | "viewport" | "itemGroup" | "item" | "nextTrigger" | "prevTrigger" | "indicatorGroup" | "indicator" | "control", 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