@mekari/pixel3-styled-system 0.0.0

package/recipes/spinner-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SpinnerRecipeVariant {
+  size: "sm" | "md"
+}
+
+type SpinnerRecipeVariantMap = {
+  [key in keyof SpinnerRecipeVariant]: Array<SpinnerRecipeVariant[key]>
+}
+
+export type SpinnerRecipeVariantProps = {
+  [key in keyof SpinnerRecipeVariant]?: ConditionalValue<SpinnerRecipeVariant[key]> | undefined
+}
+
+export interface SpinnerRecipeRecipe {
+  __type: SpinnerRecipeVariantProps
+  (props?: SpinnerRecipeVariantProps): string
+  raw: (props?: SpinnerRecipeVariantProps) => SpinnerRecipeVariantProps
+  variantMap: SpinnerRecipeVariantMap
+  variantKeys: Array<keyof SpinnerRecipeVariant>
+  splitVariantProps<Props extends SpinnerRecipeVariantProps>(props: Props): [SpinnerRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof SpinnerRecipeVariantProps>>]
+}
+
+
+export declare const spinnerRecipe: SpinnerRecipeRecipe

package/recipes/spinner-recipe.mjs

@@ -0,0 +1,29 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const spinnerRecipeFn = /* @__PURE__ */ createRecipe('spinner', {
+  "size": "sm"
+}, [])
+
+const spinnerRecipeVariantMap = {
+  "size": [
+    "sm",
+    "md"
+  ]
+}
+
+const spinnerRecipeVariantKeys = Object.keys(spinnerRecipeVariantMap)
+
+export const spinnerRecipe = /* @__PURE__ */ Object.assign(spinnerRecipeFn, {
+  __recipe__: true,
+  __name__: 'spinnerRecipe',
+  raw: (props) => props,
+  variantKeys: spinnerRecipeVariantKeys,
+  variantMap: spinnerRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, spinnerRecipeVariantKeys)
+  },
+})

package/recipes/tab-list-recipe.d.ts

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

package/recipes/tab-list-recipe.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tabListRecipeFn = /* @__PURE__ */ createRecipe('tab-list', {}, [])
+
+const tabListRecipeVariantMap = {}
+
+const tabListRecipeVariantKeys = Object.keys(tabListRecipeVariantMap)
+
+export const tabListRecipe = /* @__PURE__ */ Object.assign(tabListRecipeFn, {
+  __recipe__: true,
+  __name__: 'tabListRecipe',
+  raw: (props) => props,
+  variantKeys: tabListRecipeVariantKeys,
+  variantMap: tabListRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tabListRecipeVariantKeys)
+  },
+})

package/recipes/tab-recipe.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TabRecipeVariant {
+  variantColor: "blue" | "green" | "orange" | "red" | "gray"
+isSelected: boolean
+}
+
+type TabRecipeVariantMap = {
+  [key in keyof TabRecipeVariant]: Array<TabRecipeVariant[key]>
+}
+
+export type TabRecipeVariantProps = {
+  [key in keyof TabRecipeVariant]?: TabRecipeVariant[key] | undefined
+}
+
+export interface TabRecipeRecipe {
+  __type: TabRecipeVariantProps
+  (props?: TabRecipeVariantProps): string
+  raw: (props?: TabRecipeVariantProps) => TabRecipeVariantProps
+  variantMap: TabRecipeVariantMap
+  variantKeys: Array<keyof TabRecipeVariant>
+  splitVariantProps<Props extends TabRecipeVariantProps>(props: Props): [TabRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TabRecipeVariantProps>>]
+}
+
+
+export declare const tabRecipe: TabRecipeRecipe

package/recipes/tab-recipe.mjs

@@ -0,0 +1,87 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tabRecipeFn = /* @__PURE__ */ createRecipe('tab', {
+  "variantColor": "blue",
+  "isSelected": false
+}, [
+  {
+    "variantColor": "blue",
+    "isSelected": true,
+    "css": {
+      "color": "blue.400",
+      "_hover": {
+        "color": "blue.500"
+      }
+    }
+  },
+  {
+    "variantColor": "green",
+    "isSelected": true,
+    "css": {
+      "color": "green.400",
+      "_hover": {
+        "color": "green.500"
+      }
+    }
+  },
+  {
+    "variantColor": "orange",
+    "isSelected": true,
+    "css": {
+      "color": "orange.400",
+      "_hover": {
+        "color": "orange.500"
+      }
+    }
+  },
+  {
+    "variantColor": "red",
+    "isSelected": true,
+    "css": {
+      "color": "red.400",
+      "_hover": {
+        "color": "red.500"
+      }
+    }
+  },
+  {
+    "variantColor": "gray",
+    "isSelected": true,
+    "css": {
+      "color": "gray.400",
+      "_hover": {
+        "color": "gray.500"
+      }
+    }
+  }
+])
+
+const tabRecipeVariantMap = {
+  "variantColor": [
+    "blue",
+    "green",
+    "orange",
+    "red",
+    "gray"
+  ],
+  "isSelected": [
+    "true"
+  ]
+}
+
+const tabRecipeVariantKeys = Object.keys(tabRecipeVariantMap)
+
+export const tabRecipe = /* @__PURE__ */ Object.assign(tabRecipeFn, {
+  __recipe__: true,
+  __name__: 'tabRecipe',
+  raw: (props) => props,
+  variantKeys: tabRecipeVariantKeys,
+  variantMap: tabRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tabRecipeVariantKeys)
+  },
+})

package/recipes/table-container-recipe.d.ts

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

package/recipes/table-container-recipe.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tableContainerRecipeFn = /* @__PURE__ */ createRecipe('table-container', {}, [])
+
+const tableContainerRecipeVariantMap = {}
+
+const tableContainerRecipeVariantKeys = Object.keys(tableContainerRecipeVariantMap)
+
+export const tableContainerRecipe = /* @__PURE__ */ Object.assign(tableContainerRecipeFn, {
+  __recipe__: true,
+  __name__: 'tableContainerRecipe',
+  raw: (props) => props,
+  variantKeys: tableContainerRecipeVariantKeys,
+  variantMap: tableContainerRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tableContainerRecipeVariantKeys)
+  },
+})

package/recipes/table-head-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TableHeadRecipeVariant {
+  
+}
+
+type TableHeadRecipeVariantMap = {
+  [key in keyof TableHeadRecipeVariant]: Array<TableHeadRecipeVariant[key]>
+}
+
+export type TableHeadRecipeVariantProps = {
+  [key in keyof TableHeadRecipeVariant]?: ConditionalValue<TableHeadRecipeVariant[key]>
+}
+
+export interface TableHeadRecipeRecipe {
+  __type: TableHeadRecipeVariantProps
+  (props?: TableHeadRecipeVariantProps): string
+  raw: (props?: TableHeadRecipeVariantProps) => TableHeadRecipeVariantProps
+  variantMap: TableHeadRecipeVariantMap
+  variantKeys: Array<keyof TableHeadRecipeVariant>
+  splitVariantProps<Props extends TableHeadRecipeVariantProps>(props: Props): [TableHeadRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TableHeadRecipeVariantProps>>]
+}
+
+
+export declare const tableHeadRecipe: TableHeadRecipeRecipe

package/recipes/table-head-recipe.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tableHeadRecipeFn = /* @__PURE__ */ createRecipe('table-head', {}, [])
+
+const tableHeadRecipeVariantMap = {}
+
+const tableHeadRecipeVariantKeys = Object.keys(tableHeadRecipeVariantMap)
+
+export const tableHeadRecipe = /* @__PURE__ */ Object.assign(tableHeadRecipeFn, {
+  __recipe__: true,
+  __name__: 'tableHeadRecipe',
+  raw: (props) => props,
+  variantKeys: tableHeadRecipeVariantKeys,
+  variantMap: tableHeadRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tableHeadRecipeVariantKeys)
+  },
+})

package/recipes/table-recipe.d.ts

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

package/recipes/table-recipe.mjs

@@ -0,0 +1,22 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const tableRecipeFn = /* @__PURE__ */ createRecipe('table', {}, [])
+
+const tableRecipeVariantMap = {}
+
+const tableRecipeVariantKeys = Object.keys(tableRecipeVariantMap)
+
+export const tableRecipe = /* @__PURE__ */ Object.assign(tableRecipeFn, {
+  __recipe__: true,
+  __name__: 'tableRecipe',
+  raw: (props) => props,
+  variantKeys: tableRecipeVariantKeys,
+  variantMap: tableRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, tableRecipeVariantKeys)
+  },
+})

package/recipes/tag-recipe.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TagRecipeVariant {
+  size: "sm" | "md"
+variant: "gray" | "red"
+}
+
+type TagRecipeVariantMap = {
+  [key in keyof TagRecipeVariant]: Array<TagRecipeVariant[key]>
+}
+
+export type TagRecipeVariantProps = {
+  [key in keyof TagRecipeVariant]?: TagRecipeVariant[key]
+}
+
+export interface TagRecipeRecipe {
+  __type: TagRecipeVariantProps
+  (props?: TagRecipeVariantProps): Pretty<Record<"root" | "close", string>>
+  raw: (props?: TagRecipeVariantProps) => TagRecipeVariantProps
+  variantMap: TagRecipeVariantMap
+  variantKeys: Array<keyof TagRecipeVariant>
+  splitVariantProps<Props extends TagRecipeVariantProps>(props: Props): [TagRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TagRecipeVariantProps>>]
+}
+
+
+export declare const tagRecipe: TagRecipeRecipe

package/recipes/tag-recipe.mjs

@@ -0,0 +1,66 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tagRecipeDefaultVariants = {
+  "size": "md",
+  "variant": "gray"
+}
+const tagRecipeCompoundVariants = [
+  {
+    "variant": "red",
+    "css": {
+      "close": {
+        "background": "linear-gradient(270deg, #FDECEE 75%, rgba(237, 240, 242, 0) 111.54%)"
+      }
+    }
+  },
+  {
+    "size": "sm",
+    "css": {
+      "close": {
+        "paddingTop": "0"
+      }
+    }
+  }
+]
+
+const tagRecipeSlotNames = [
+  [
+    "root",
+    "tag__root"
+  ],
+  [
+    "close",
+    "tag__close"
+  ]
+]
+const tagRecipeSlotFns = /* @__PURE__ */ tagRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tagRecipeDefaultVariants, getSlotCompoundVariant(tagRecipeCompoundVariants, slotName))])
+
+const tagRecipeFn = (props = {}) => {
+  return Object.fromEntries(tagRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const tagRecipeVariantKeys = [
+  "size",
+  "variant"
+]
+
+export const tagRecipe = /* @__PURE__ */ Object.assign(tagRecipeFn, {
+  __recipe__: false,
+  __name__: 'tagRecipe',
+  raw: (props) => props,
+  variantKeys: tagRecipeVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md"
+  ],
+  "variant": [
+    "gray",
+    "red"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tagRecipeVariantKeys)
+  },
+})

package/recipes/tag-slot-recipe.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TagSlotRecipeVariant {
+  size: "sm" | "md"
+variant: "gray" | "red"
+}
+
+type TagSlotRecipeVariantMap = {
+  [key in keyof TagSlotRecipeVariant]: Array<TagSlotRecipeVariant[key]>
+}
+
+export type TagSlotRecipeVariantProps = {
+  [key in keyof TagSlotRecipeVariant]?: TagSlotRecipeVariant[key] | undefined
+}
+
+export interface TagSlotRecipeRecipe {
+  __type: TagSlotRecipeVariantProps
+  (props?: TagSlotRecipeVariantProps): Pretty<Record<"root" | "close", string>>
+  raw: (props?: TagSlotRecipeVariantProps) => TagSlotRecipeVariantProps
+  variantMap: TagSlotRecipeVariantMap
+  variantKeys: Array<keyof TagSlotRecipeVariant>
+  splitVariantProps<Props extends TagSlotRecipeVariantProps>(props: Props): [TagSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TagSlotRecipeVariantProps>>]
+}
+
+
+export declare const tagSlotRecipe: TagSlotRecipeRecipe

package/recipes/tag-slot-recipe.mjs

@@ -0,0 +1,66 @@
+import { splitProps, getSlotCompoundVariant } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const tagSlotRecipeDefaultVariants = {
+  "size": "md",
+  "variant": "gray"
+}
+const tagSlotRecipeCompoundVariants = [
+  {
+    "variant": "red",
+    "css": {
+      "close": {
+        "background": "linear-gradient(270deg, #FDECEE 75%, rgba(237, 240, 242, 0) 111.54%)!"
+      }
+    }
+  },
+  {
+    "size": "sm",
+    "css": {
+      "close": {
+        "paddingTop": "0"
+      }
+    }
+  }
+]
+
+const tagSlotRecipeSlotNames = [
+  [
+    "root",
+    "tag__root"
+  ],
+  [
+    "close",
+    "tag__close"
+  ]
+]
+const tagSlotRecipeSlotFns = /* @__PURE__ */ tagSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, tagSlotRecipeDefaultVariants, getSlotCompoundVariant(tagSlotRecipeCompoundVariants, slotName))])
+
+const tagSlotRecipeFn = (props = {}) => {
+  return Object.fromEntries(tagSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn(props)]))
+}
+
+const tagSlotRecipeVariantKeys = [
+  "size",
+  "variant"
+]
+
+export const tagSlotRecipe = /* @__PURE__ */ Object.assign(tagSlotRecipeFn, {
+  __recipe__: false,
+  __name__: 'tagSlotRecipe',
+  raw: (props) => props,
+  variantKeys: tagSlotRecipeVariantKeys,
+  variantMap: {
+  "size": [
+    "sm",
+    "md"
+  ],
+  "variant": [
+    "gray",
+    "red"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, tagSlotRecipeVariantKeys)
+  },
+})

package/recipes/text-recipe.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TextRecipeVariant {
+  size: "h1" | "h2" | "h3" | "body" | "body-small" | "label" | "label-small" | "overline"
+weight: "regular" | "semiBold"
+}
+
+type TextRecipeVariantMap = {
+  [key in keyof TextRecipeVariant]: Array<TextRecipeVariant[key]>
+}
+
+export type TextRecipeVariantProps = {
+  [key in keyof TextRecipeVariant]?: ConditionalValue<TextRecipeVariant[key]> | undefined
+}
+
+export interface TextRecipeRecipe {
+  __type: TextRecipeVariantProps
+  (props?: TextRecipeVariantProps): string
+  raw: (props?: TextRecipeVariantProps) => TextRecipeVariantProps
+  variantMap: TextRecipeVariantMap
+  variantKeys: Array<keyof TextRecipeVariant>
+  splitVariantProps<Props extends TextRecipeVariantProps>(props: Props): [TextRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TextRecipeVariantProps>>]
+}
+
+
+export declare const textRecipe: TextRecipeRecipe

package/recipes/text-recipe.mjs

@@ -0,0 +1,40 @@
+import { splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const textRecipeFn = /* @__PURE__ */ createRecipe('text', {
+  "size": "label",
+  "weight": "regular"
+}, [])
+
+const textRecipeVariantMap = {
+  "size": [
+    "h1",
+    "h2",
+    "h3",
+    "body",
+    "body-small",
+    "label",
+    "label-small",
+    "overline"
+  ],
+  "weight": [
+    "regular",
+    "semiBold"
+  ]
+}
+
+const textRecipeVariantKeys = Object.keys(textRecipeVariantMap)
+
+export const textRecipe = /* @__PURE__ */ Object.assign(textRecipeFn, {
+  __recipe__: true,
+  __name__: 'textRecipe',
+  raw: (props) => props,
+  variantKeys: textRecipeVariantKeys,
+  variantMap: textRecipeVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, textRecipeVariantKeys)
+  },
+})

package/recipes/textarea-recipe.d.ts

@@ -0,0 +1,27 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TextareaRecipeVariant {
+  isFullWidth: boolean
+}
+
+type TextareaRecipeVariantMap = {
+  [key in keyof TextareaRecipeVariant]: Array<TextareaRecipeVariant[key]>
+}
+
+export type TextareaRecipeVariantProps = {
+  [key in keyof TextareaRecipeVariant]?: ConditionalValue<TextareaRecipeVariant[key]> | undefined
+}
+
+export interface TextareaRecipeRecipe {
+  __type: TextareaRecipeVariantProps
+  (props?: TextareaRecipeVariantProps): string
+  raw: (props?: TextareaRecipeVariantProps) => TextareaRecipeVariantProps
+  variantMap: TextareaRecipeVariantMap
+  variantKeys: Array<keyof TextareaRecipeVariant>
+  splitVariantProps<Props extends TextareaRecipeVariantProps>(props: Props): [TextareaRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof TextareaRecipeVariantProps>>]
+}
+
+
+export declare const textareaRecipe: TextareaRecipeRecipe