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

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", string>>
+  raw: (props?: FieldVariantProps) => FieldVariantProps
+  variantMap: FieldVariantMap
+  variantKeys: Array<keyof FieldVariant>
+  splitVariantProps<Props extends FieldVariantProps>(props: Props): [FieldVariantProps, Pretty<DistributiveOmit<Props, keyof FieldVariantProps>>]
+  getVariantProps: (props?: FieldVariantProps) => FieldVariantProps
+}
+
+
+export declare const field: FieldRecipe

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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