@mekari/pixel3-styled-system 0.1.6 → 0.1.7

package/recipes/avatar-group-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type AvatarGroupSlotRecipeVariantMap = {
   [key in keyof AvatarGroupSlotRecipeVariant]: Array<AvatarGroupSlotRecipeVariant[key]>
 }
 
+type AvatarGroupSlotRecipeSlot = "root" | "excess"
+
 export type AvatarGroupSlotRecipeVariantProps = {
   [key in keyof AvatarGroupSlotRecipeVariant]?: ConditionalValue<AvatarGroupSlotRecipeVariant[key]> | undefined
 }
 
 export interface AvatarGroupSlotRecipeRecipe {
+  __slot: AvatarGroupSlotRecipeSlot
   __type: AvatarGroupSlotRecipeVariantProps
-  (props?: AvatarGroupSlotRecipeVariantProps): Pretty<Record<"root" | "excess", string>>
+  (props?: AvatarGroupSlotRecipeVariantProps): Pretty<Record<AvatarGroupSlotRecipeSlot, string>>
   raw: (props?: AvatarGroupSlotRecipeVariantProps) => AvatarGroupSlotRecipeVariantProps
   variantMap: AvatarGroupSlotRecipeVariantMap
   variantKeys: Array<keyof AvatarGroupSlotRecipeVariant>

package/recipes/avatar-group-slot-recipe.mjs

@@ -29,6 +29,7 @@ export const avatarGroupSlotRecipe = /* @__PURE__ */ Object.assign(avatarGroupSl
   __recipe__: false,
   __name__: 'avatarGroupSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: avatarGroupSlotRecipeVariantKeys,
   variantMap: {
   "size": [

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

@@ -19,13 +19,16 @@ type AvatarSlotRecipeVariantMap = {
   [key in keyof AvatarSlotRecipeVariant]: Array<AvatarSlotRecipeVariant[key]>
 }
 
+type AvatarSlotRecipeSlot = "root" | "fallback" | "image" | "icon"
+
 export type AvatarSlotRecipeVariantProps = {
   [key in keyof AvatarSlotRecipeVariant]?: AvatarSlotRecipeVariant[key] | undefined
 }
 
 export interface AvatarSlotRecipeRecipe {
+  __slot: AvatarSlotRecipeSlot
   __type: AvatarSlotRecipeVariantProps
-  (props?: AvatarSlotRecipeVariantProps): Pretty<Record<"root" | "fallback" | "image" | "icon", string>>
+  (props?: AvatarSlotRecipeVariantProps): Pretty<Record<AvatarSlotRecipeSlot, string>>
   raw: (props?: AvatarSlotRecipeVariantProps) => AvatarSlotRecipeVariantProps
   variantMap: AvatarSlotRecipeVariantMap
   variantKeys: Array<keyof AvatarSlotRecipeVariant>

package/recipes/avatar-slot-recipe.mjs

@@ -91,6 +91,7 @@ export const avatarSlotRecipe = /* @__PURE__ */ Object.assign(avatarSlotRecipeFn
   __recipe__: false,
   __name__: 'avatarSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: avatarSlotRecipeVariantKeys,
   variantMap: {
   "variant": [

package/recipes/badge-recipe.d.ts

@@ -21,11 +21,14 @@ type BadgeRecipeVariantMap = {
   [key in keyof BadgeRecipeVariant]: Array<BadgeRecipeVariant[key]>
 }
 
+
+
 export type BadgeRecipeVariantProps = {
   [key in keyof BadgeRecipeVariant]?: BadgeRecipeVariant[key] | undefined
 }
 
 export interface BadgeRecipeRecipe {
+  
   __type: BadgeRecipeVariantProps
   (props?: BadgeRecipeVariantProps): string
   raw: (props?: BadgeRecipeVariantProps) => BadgeRecipeVariantProps

package/recipes/banner-close-button-recipe.d.ts

@@ -10,11 +10,14 @@ type BannerCloseButtonRecipeVariantMap = {
   [key in keyof BannerCloseButtonRecipeVariant]: Array<BannerCloseButtonRecipeVariant[key]>
 }
 
+
+
 export type BannerCloseButtonRecipeVariantProps = {
   [key in keyof BannerCloseButtonRecipeVariant]?: ConditionalValue<BannerCloseButtonRecipeVariant[key]> | undefined
 }
 
 export interface BannerCloseButtonRecipeRecipe {
+  
   __type: BannerCloseButtonRecipeVariantProps
   (props?: BannerCloseButtonRecipeVariantProps): string
   raw: (props?: BannerCloseButtonRecipeVariantProps) => BannerCloseButtonRecipeVariantProps

package/recipes/banner-description-recipe.d.ts

@@ -10,11 +10,14 @@ type BannerDescriptionRecipeVariantMap = {
   [key in keyof BannerDescriptionRecipeVariant]: Array<BannerDescriptionRecipeVariant[key]>
 }
 
+
+
 export type BannerDescriptionRecipeVariantProps = {
   [key in keyof BannerDescriptionRecipeVariant]?: ConditionalValue<BannerDescriptionRecipeVariant[key]> | undefined
 }
 
 export interface BannerDescriptionRecipeRecipe {
+  
   __type: BannerDescriptionRecipeVariantProps
   (props?: BannerDescriptionRecipeVariantProps): string
   raw: (props?: BannerDescriptionRecipeVariantProps) => BannerDescriptionRecipeVariantProps

package/recipes/banner-icon-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type BannerIconSlotRecipeVariantMap = {
   [key in keyof BannerIconSlotRecipeVariant]: Array<BannerIconSlotRecipeVariant[key]>
 }
 
+type BannerIconSlotRecipeSlot = "root" | "custom"
+
 export type BannerIconSlotRecipeVariantProps = {
   [key in keyof BannerIconSlotRecipeVariant]?: ConditionalValue<BannerIconSlotRecipeVariant[key]> | undefined
 }
 
 export interface BannerIconSlotRecipeRecipe {
+  __slot: BannerIconSlotRecipeSlot
   __type: BannerIconSlotRecipeVariantProps
-  (props?: BannerIconSlotRecipeVariantProps): Pretty<Record<"root" | "custom", string>>
+  (props?: BannerIconSlotRecipeVariantProps): Pretty<Record<BannerIconSlotRecipeSlot, string>>
   raw: (props?: BannerIconSlotRecipeVariantProps) => BannerIconSlotRecipeVariantProps
   variantMap: BannerIconSlotRecipeVariantMap
   variantKeys: Array<keyof BannerIconSlotRecipeVariant>

package/recipes/banner-icon-slot-recipe.mjs

@@ -27,6 +27,7 @@ export const bannerIconSlotRecipe = /* @__PURE__ */ Object.assign(bannerIconSlot
   __recipe__: false,
   __name__: 'bannerIconSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: bannerIconSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/banner-link-recipe.d.ts

@@ -10,11 +10,14 @@ type BannerLinkRecipeVariantMap = {
   [key in keyof BannerLinkRecipeVariant]: Array<BannerLinkRecipeVariant[key]>
 }
 
+
+
 export type BannerLinkRecipeVariantProps = {
   [key in keyof BannerLinkRecipeVariant]?: ConditionalValue<BannerLinkRecipeVariant[key]> | undefined
 }
 
 export interface BannerLinkRecipeRecipe {
+  
   __type: BannerLinkRecipeVariantProps
   (props?: BannerLinkRecipeVariantProps): string
   raw: (props?: BannerLinkRecipeVariantProps) => BannerLinkRecipeVariantProps

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

@@ -13,13 +13,16 @@ type BannerSlotRecipeVariantMap = {
   [key in keyof BannerSlotRecipeVariant]: Array<BannerSlotRecipeVariant[key]>
 }
 
+type BannerSlotRecipeSlot = "root" | "body"
+
 export type BannerSlotRecipeVariantProps = {
   [key in keyof BannerSlotRecipeVariant]?: ConditionalValue<BannerSlotRecipeVariant[key]> | undefined
 }
 
 export interface BannerSlotRecipeRecipe {
+  __slot: BannerSlotRecipeSlot
   __type: BannerSlotRecipeVariantProps
-  (props?: BannerSlotRecipeVariantProps): Pretty<Record<"root" | "body", string>>
+  (props?: BannerSlotRecipeVariantProps): Pretty<Record<BannerSlotRecipeSlot, string>>
   raw: (props?: BannerSlotRecipeVariantProps) => BannerSlotRecipeVariantProps
   variantMap: BannerSlotRecipeVariantMap
   variantKeys: Array<keyof BannerSlotRecipeVariant>

package/recipes/banner-slot-recipe.mjs

@@ -31,6 +31,7 @@ export const bannerSlotRecipe = /* @__PURE__ */ Object.assign(bannerSlotRecipeFn
   __recipe__: false,
   __name__: 'bannerSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: bannerSlotRecipeVariantKeys,
   variantMap: {
   "variant": [

package/recipes/banner-title-recipe.d.ts

@@ -10,11 +10,14 @@ type BannerTitleRecipeVariantMap = {
   [key in keyof BannerTitleRecipeVariant]: Array<BannerTitleRecipeVariant[key]>
 }
 
+
+
 export type BannerTitleRecipeVariantProps = {
   [key in keyof BannerTitleRecipeVariant]?: ConditionalValue<BannerTitleRecipeVariant[key]> | undefined
 }
 
 export interface BannerTitleRecipeRecipe {
+  
   __type: BannerTitleRecipeVariantProps
   (props?: BannerTitleRecipeVariantProps): string
   raw: (props?: BannerTitleRecipeVariantProps) => BannerTitleRecipeVariantProps

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

@@ -13,13 +13,16 @@ type BroadcastSlotRecipeVariantMap = {
   [key in keyof BroadcastSlotRecipeVariant]: Array<BroadcastSlotRecipeVariant[key]>
 }
 
+type BroadcastSlotRecipeSlot = "root" | "container" | "wrapper" | "icon" | "label" | "textLink" | "action" | "close"
+
 export type BroadcastSlotRecipeVariantProps = {
   [key in keyof BroadcastSlotRecipeVariant]?: ConditionalValue<BroadcastSlotRecipeVariant[key]> | undefined
 }
 
 export interface BroadcastSlotRecipeRecipe {
+  __slot: BroadcastSlotRecipeSlot
   __type: BroadcastSlotRecipeVariantProps
-  (props?: BroadcastSlotRecipeVariantProps): Pretty<Record<"root" | "container" | "wrapper" | "icon" | "label" | "textLink" | "action" | "close", string>>
+  (props?: BroadcastSlotRecipeVariantProps): Pretty<Record<BroadcastSlotRecipeSlot, string>>
   raw: (props?: BroadcastSlotRecipeVariantProps) => BroadcastSlotRecipeVariantProps
   variantMap: BroadcastSlotRecipeVariantMap
   variantKeys: Array<keyof BroadcastSlotRecipeVariant>

package/recipes/broadcast-slot-recipe.mjs

@@ -55,6 +55,7 @@ export const broadcastSlotRecipe = /* @__PURE__ */ Object.assign(broadcastSlotRe
   __recipe__: false,
   __name__: 'broadcastSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: broadcastSlotRecipeVariantKeys,
   variantMap: {
   "variant": [

package/recipes/button-group-recipe.d.ts

@@ -10,11 +10,14 @@ type ButtonGroupRecipeVariantMap = {
   [key in keyof ButtonGroupRecipeVariant]: Array<ButtonGroupRecipeVariant[key]>
 }
 
+
+
 export type ButtonGroupRecipeVariantProps = {
   [key in keyof ButtonGroupRecipeVariant]?: ConditionalValue<ButtonGroupRecipeVariant[key]> | undefined
 }
 
 export interface ButtonGroupRecipeRecipe {
+  
   __type: ButtonGroupRecipeVariantProps
   (props?: ButtonGroupRecipeVariantProps): string
   raw: (props?: ButtonGroupRecipeVariantProps) => ButtonGroupRecipeVariantProps

package/recipes/button-recipe.d.ts

@@ -17,11 +17,14 @@ type ButtonRecipeVariantMap = {
   [key in keyof ButtonRecipeVariant]: Array<ButtonRecipeVariant[key]>
 }
 
+
+
 export type ButtonRecipeVariantProps = {
   [key in keyof ButtonRecipeVariant]?: ButtonRecipeVariant[key] | undefined
 }
 
 export interface ButtonRecipeRecipe {
+  
   __type: ButtonRecipeVariantProps
   (props?: ButtonRecipeVariantProps): string
   raw: (props?: ButtonRecipeVariantProps) => ButtonRecipeVariantProps

package/recipes/calendar-panel-range-recipe.d.ts

@@ -10,11 +10,14 @@ type CalendarPanelRangeRecipeVariantMap = {
   [key in keyof CalendarPanelRangeRecipeVariant]: Array<CalendarPanelRangeRecipeVariant[key]>
 }
 
+
+
 export type CalendarPanelRangeRecipeVariantProps = {
   [key in keyof CalendarPanelRangeRecipeVariant]?: ConditionalValue<CalendarPanelRangeRecipeVariant[key]> | undefined
 }
 
 export interface CalendarPanelRangeRecipeRecipe {
+  
   __type: CalendarPanelRangeRecipeVariantProps
   (props?: CalendarPanelRangeRecipeVariantProps): string
   raw: (props?: CalendarPanelRangeRecipeVariantProps) => CalendarPanelRangeRecipeVariantProps

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

@@ -10,13 +10,16 @@ type CarouselSlotRecipeVariantMap = {
   [key in keyof CarouselSlotRecipeVariant]: Array<CarouselSlotRecipeVariant[key]>
 }
 
+type CarouselSlotRecipeSlot = "root" | "buttonRight" | "buttonLeft"
+
 export type CarouselSlotRecipeVariantProps = {
   [key in keyof CarouselSlotRecipeVariant]?: ConditionalValue<CarouselSlotRecipeVariant[key]> | undefined
 }
 
 export interface CarouselSlotRecipeRecipe {
+  __slot: CarouselSlotRecipeSlot
   __type: CarouselSlotRecipeVariantProps
-  (props?: CarouselSlotRecipeVariantProps): Pretty<Record<"root" | "buttonRight" | "buttonLeft", string>>
+  (props?: CarouselSlotRecipeVariantProps): Pretty<Record<CarouselSlotRecipeSlot, string>>
   raw: (props?: CarouselSlotRecipeVariantProps) => CarouselSlotRecipeVariantProps
   variantMap: CarouselSlotRecipeVariantMap
   variantKeys: Array<keyof CarouselSlotRecipeVariant>

package/recipes/carousel-slot-recipe.mjs

@@ -31,6 +31,7 @@ export const carouselSlotRecipe = /* @__PURE__ */ Object.assign(carouselSlotReci
   __recipe__: false,
   __name__: 'carouselSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: carouselSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

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

@@ -10,13 +10,16 @@ type ChartSlotRecipeVariantMap = {
   [key in keyof ChartSlotRecipeVariant]: Array<ChartSlotRecipeVariant[key]>
 }
 
+type ChartSlotRecipeSlot = "root" | "chartHeader" | "chartWrapper" | "chartContainer" | "canvasContainer" | "chartLegend" | "legendWrapper" | "legendBox" | "chartTooltip" | "tooltipWrapper" | "tooltipRow" | "tooltipItem" | "tooltipBox"
+
 export type ChartSlotRecipeVariantProps = {
   [key in keyof ChartSlotRecipeVariant]?: ConditionalValue<ChartSlotRecipeVariant[key]> | undefined
 }
 
 export interface ChartSlotRecipeRecipe {
+  __slot: ChartSlotRecipeSlot
   __type: ChartSlotRecipeVariantProps
-  (props?: ChartSlotRecipeVariantProps): Pretty<Record<"root" | "chartHeader" | "chartWrapper" | "chartContainer" | "canvasContainer" | "chartLegend" | "legendWrapper" | "legendBox" | "chartTooltip" | "tooltipWrapper" | "tooltipRow" | "tooltipItem" | "tooltipBox", string>>
+  (props?: ChartSlotRecipeVariantProps): Pretty<Record<ChartSlotRecipeSlot, string>>
   raw: (props?: ChartSlotRecipeVariantProps) => ChartSlotRecipeVariantProps
   variantMap: ChartSlotRecipeVariantMap
   variantKeys: Array<keyof ChartSlotRecipeVariant>

package/recipes/chart-slot-recipe.mjs

@@ -71,6 +71,7 @@ export const chartSlotRecipe = /* @__PURE__ */ Object.assign(chartSlotRecipeFn,
   __recipe__: false,
   __name__: 'chartSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: chartSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

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

@@ -10,13 +10,16 @@ type CheckboxSlotRecipeVariantMap = {
   [key in keyof CheckboxSlotRecipeVariant]: Array<CheckboxSlotRecipeVariant[key]>
 }
 
+type CheckboxSlotRecipeSlot = "root" | "control" | "label"
+
 export type CheckboxSlotRecipeVariantProps = {
   [key in keyof CheckboxSlotRecipeVariant]?: ConditionalValue<CheckboxSlotRecipeVariant[key]> | undefined
 }
 
 export interface CheckboxSlotRecipeRecipe {
+  __slot: CheckboxSlotRecipeSlot
   __type: CheckboxSlotRecipeVariantProps
-  (props?: CheckboxSlotRecipeVariantProps): Pretty<Record<"root" | "control" | "label", string>>
+  (props?: CheckboxSlotRecipeVariantProps): Pretty<Record<CheckboxSlotRecipeSlot, string>>
   raw: (props?: CheckboxSlotRecipeVariantProps) => CheckboxSlotRecipeVariantProps
   variantMap: CheckboxSlotRecipeVariantMap
   variantKeys: Array<keyof CheckboxSlotRecipeVariant>

package/recipes/checkbox-slot-recipe.mjs

@@ -31,6 +31,7 @@ export const checkboxSlotRecipe = /* @__PURE__ */ Object.assign(checkboxSlotReci
   __recipe__: false,
   __name__: 'checkboxSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: checkboxSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/color-picker-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type ColorPickerSlotRecipeVariantMap = {
   [key in keyof ColorPickerSlotRecipeVariant]: Array<ColorPickerSlotRecipeVariant[key]>
 }
 
+type ColorPickerSlotRecipeSlot = "root" | "popoverTrigger" | "boxColor" | "inputTrigger" | "iconDropdown" | "popoverContent" | "wrapperAdvance" | "wrapperBasic" | "wrapperSaturation" | "wrapperHue" | "wrapperInput" | "boxPreset" | "wrapperPreset" | "wrapperBasicPreset"
+
 export type ColorPickerSlotRecipeVariantProps = {
   [key in keyof ColorPickerSlotRecipeVariant]?: ConditionalValue<ColorPickerSlotRecipeVariant[key]> | undefined
 }
 
 export interface ColorPickerSlotRecipeRecipe {
+  __slot: ColorPickerSlotRecipeSlot
   __type: ColorPickerSlotRecipeVariantProps
-  (props?: ColorPickerSlotRecipeVariantProps): Pretty<Record<"root" | "popoverTrigger" | "boxColor" | "inputTrigger" | "iconDropdown" | "popoverContent" | "wrapperAdvance" | "wrapperBasic" | "wrapperSaturation" | "wrapperHue" | "wrapperInput" | "boxPreset" | "wrapperPreset" | "wrapperBasicPreset", string>>
+  (props?: ColorPickerSlotRecipeVariantProps): Pretty<Record<ColorPickerSlotRecipeSlot, string>>
   raw: (props?: ColorPickerSlotRecipeVariantProps) => ColorPickerSlotRecipeVariantProps
   variantMap: ColorPickerSlotRecipeVariantMap
   variantKeys: Array<keyof ColorPickerSlotRecipeVariant>

package/recipes/color-picker-slot-recipe.mjs

@@ -75,6 +75,7 @@ export const colorPickerSlotRecipe = /* @__PURE__ */ Object.assign(colorPickerSl
   __recipe__: false,
   __name__: 'colorPickerSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: colorPickerSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/date-item-recipe.d.ts

@@ -10,11 +10,14 @@ type DateItemRecipeVariantMap = {
   [key in keyof DateItemRecipeVariant]: Array<DateItemRecipeVariant[key]>
 }
 
+
+
 export type DateItemRecipeVariantProps = {
   [key in keyof DateItemRecipeVariant]?: ConditionalValue<DateItemRecipeVariant[key]> | undefined
 }
 
 export interface DateItemRecipeRecipe {
+  
   __type: DateItemRecipeVariantProps
   (props?: DateItemRecipeVariantProps): string
   raw: (props?: DateItemRecipeVariantProps) => DateItemRecipeVariantProps

package/recipes/date-picker-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type DatePickerSlotRecipeVariantMap = {
   [key in keyof DatePickerSlotRecipeVariant]: Array<DatePickerSlotRecipeVariant[key]>
 }
 
+type DatePickerSlotRecipeSlot = "root" | "popoverContent"
+
 export type DatePickerSlotRecipeVariantProps = {
   [key in keyof DatePickerSlotRecipeVariant]?: ConditionalValue<DatePickerSlotRecipeVariant[key]> | undefined
 }
 
 export interface DatePickerSlotRecipeRecipe {
+  __slot: DatePickerSlotRecipeSlot
   __type: DatePickerSlotRecipeVariantProps
-  (props?: DatePickerSlotRecipeVariantProps): Pretty<Record<"root" | "popoverContent", string>>
+  (props?: DatePickerSlotRecipeVariantProps): Pretty<Record<DatePickerSlotRecipeSlot, string>>
   raw: (props?: DatePickerSlotRecipeVariantProps) => DatePickerSlotRecipeVariantProps
   variantMap: DatePickerSlotRecipeVariantMap
   variantKeys: Array<keyof DatePickerSlotRecipeVariant>

package/recipes/date-picker-slot-recipe.mjs

@@ -29,6 +29,7 @@ export const datePickerSlotRecipe = /* @__PURE__ */ Object.assign(datePickerSlot
   __recipe__: false,
   __name__: 'datePickerSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: datePickerSlotRecipeVariantKeys,
   variantMap: {
   "variant": [

package/recipes/day-item-recipe.d.ts

@@ -10,11 +10,14 @@ type DayItemRecipeVariantMap = {
   [key in keyof DayItemRecipeVariant]: Array<DayItemRecipeVariant[key]>
 }
 
+
+
 export type DayItemRecipeVariantProps = {
   [key in keyof DayItemRecipeVariant]?: ConditionalValue<DayItemRecipeVariant[key]> | undefined
 }
 
 export interface DayItemRecipeRecipe {
+  
   __type: DayItemRecipeVariantProps
   (props?: DayItemRecipeVariantProps): string
   raw: (props?: DayItemRecipeVariantProps) => DayItemRecipeVariantProps

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

@@ -10,13 +10,16 @@ type DividerSlotRecipeVariantMap = {
   [key in keyof DividerSlotRecipeVariant]: Array<DividerSlotRecipeVariant[key]>
 }
 
+type DividerSlotRecipeSlot = "root" | "label"
+
 export type DividerSlotRecipeVariantProps = {
   [key in keyof DividerSlotRecipeVariant]?: ConditionalValue<DividerSlotRecipeVariant[key]> | undefined
 }
 
 export interface DividerSlotRecipeRecipe {
+  __slot: DividerSlotRecipeSlot
   __type: DividerSlotRecipeVariantProps
-  (props?: DividerSlotRecipeVariantProps): Pretty<Record<"root" | "label", string>>
+  (props?: DividerSlotRecipeVariantProps): Pretty<Record<DividerSlotRecipeSlot, string>>
   raw: (props?: DividerSlotRecipeVariantProps) => DividerSlotRecipeVariantProps
   variantMap: DividerSlotRecipeVariantMap
   variantKeys: Array<keyof DividerSlotRecipeVariant>

package/recipes/divider-slot-recipe.mjs

@@ -27,6 +27,7 @@ export const dividerSlotRecipe = /* @__PURE__ */ Object.assign(dividerSlotRecipe
   __recipe__: false,
   __name__: 'dividerSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: dividerSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

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

@@ -10,13 +10,16 @@ type DropzoneSlotRecipeVariantMap = {
   [key in keyof DropzoneSlotRecipeVariant]: Array<DropzoneSlotRecipeVariant[key]>
 }
 
+type DropzoneSlotRecipeSlot = "root" | "wrapper" | "box" | "logoBox" | "productBox" | "avatarBox" | "overlayWrapper" | "overlay" | "preview" | "overlayPreview" | "clearButton"
+
 export type DropzoneSlotRecipeVariantProps = {
   [key in keyof DropzoneSlotRecipeVariant]?: ConditionalValue<DropzoneSlotRecipeVariant[key]> | undefined
 }
 
 export interface DropzoneSlotRecipeRecipe {
+  __slot: DropzoneSlotRecipeSlot
   __type: DropzoneSlotRecipeVariantProps
-  (props?: DropzoneSlotRecipeVariantProps): Pretty<Record<"root" | "wrapper" | "box" | "logoBox" | "productBox" | "avatarBox" | "overlayWrapper" | "overlay" | "preview" | "overlayPreview" | "clearButton", string>>
+  (props?: DropzoneSlotRecipeVariantProps): Pretty<Record<DropzoneSlotRecipeSlot, string>>
   raw: (props?: DropzoneSlotRecipeVariantProps) => DropzoneSlotRecipeVariantProps
   variantMap: DropzoneSlotRecipeVariantMap
   variantKeys: Array<keyof DropzoneSlotRecipeVariant>

package/recipes/dropzone-slot-recipe.mjs

@@ -63,6 +63,7 @@ export const dropzoneSlotRecipe = /* @__PURE__ */ Object.assign(dropzoneSlotReci
   __recipe__: false,
   __name__: 'dropzoneSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: dropzoneSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/form-control-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type FormControlSlotRecipeVariantMap = {
   [key in keyof FormControlSlotRecipeVariant]: Array<FormControlSlotRecipeVariant[key]>
 }
 
+type FormControlSlotRecipeSlot = "root" | "label" | "required" | "helpText" | "errorMessage"
+
 export type FormControlSlotRecipeVariantProps = {
   [key in keyof FormControlSlotRecipeVariant]?: ConditionalValue<FormControlSlotRecipeVariant[key]> | undefined
 }
 
 export interface FormControlSlotRecipeRecipe {
+  __slot: FormControlSlotRecipeSlot
   __type: FormControlSlotRecipeVariantProps
-  (props?: FormControlSlotRecipeVariantProps): Pretty<Record<"root" | "label" | "required" | "helpText" | "errorMessage", string>>
+  (props?: FormControlSlotRecipeVariantProps): Pretty<Record<FormControlSlotRecipeSlot, string>>
   raw: (props?: FormControlSlotRecipeVariantProps) => FormControlSlotRecipeVariantProps
   variantMap: FormControlSlotRecipeVariantMap
   variantKeys: Array<keyof FormControlSlotRecipeVariant>

package/recipes/form-control-slot-recipe.mjs

@@ -39,6 +39,7 @@ export const formControlSlotRecipe = /* @__PURE__ */ Object.assign(formControlSl
   __recipe__: false,
   __name__: 'formControlSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: formControlSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

package/recipes/icon-recipe.d.ts

@@ -13,11 +13,14 @@ type IconRecipeVariantMap = {
   [key in keyof IconRecipeVariant]: Array<IconRecipeVariant[key]>
 }
 
+
+
 export type IconRecipeVariantProps = {
   [key in keyof IconRecipeVariant]?: ConditionalValue<IconRecipeVariant[key]> | undefined
 }
 
 export interface IconRecipeRecipe {
+  
   __type: IconRecipeVariantProps
   (props?: IconRecipeVariantProps): string
   raw: (props?: IconRecipeVariantProps) => IconRecipeVariantProps

package/recipes/input-addon-slot-recipe.d.ts

@@ -17,13 +17,16 @@ type InputAddonSlotRecipeVariantMap = {
   [key in keyof InputAddonSlotRecipeVariant]: Array<InputAddonSlotRecipeVariant[key]>
 }
 
+type InputAddonSlotRecipeSlot = "root"
+
 export type InputAddonSlotRecipeVariantProps = {
   [key in keyof InputAddonSlotRecipeVariant]?: ConditionalValue<InputAddonSlotRecipeVariant[key]> | undefined
 }
 
 export interface InputAddonSlotRecipeRecipe {
+  __slot: InputAddonSlotRecipeSlot
   __type: InputAddonSlotRecipeVariantProps
-  (props?: InputAddonSlotRecipeVariantProps): Pretty<Record<"root", string>>
+  (props?: InputAddonSlotRecipeVariantProps): Pretty<Record<InputAddonSlotRecipeSlot, string>>
   raw: (props?: InputAddonSlotRecipeVariantProps) => InputAddonSlotRecipeVariantProps
   variantMap: InputAddonSlotRecipeVariantMap
   variantKeys: Array<keyof InputAddonSlotRecipeVariant>

package/recipes/input-addon-slot-recipe.mjs

@@ -29,6 +29,7 @@ export const inputAddonSlotRecipe = /* @__PURE__ */ Object.assign(inputAddonSlot
   __recipe__: false,
   __name__: 'inputAddonSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: inputAddonSlotRecipeVariantKeys,
   variantMap: {
   "placement": [

package/recipes/input-group-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type InputGroupSlotRecipeVariantMap = {
   [key in keyof InputGroupSlotRecipeVariant]: Array<InputGroupSlotRecipeVariant[key]>
 }
 
+type InputGroupSlotRecipeSlot = "root"
+
 export type InputGroupSlotRecipeVariantProps = {
   [key in keyof InputGroupSlotRecipeVariant]?: ConditionalValue<InputGroupSlotRecipeVariant[key]> | undefined
 }
 
 export interface InputGroupSlotRecipeRecipe {
+  __slot: InputGroupSlotRecipeSlot
   __type: InputGroupSlotRecipeVariantProps
-  (props?: InputGroupSlotRecipeVariantProps): Pretty<Record<"root", string>>
+  (props?: InputGroupSlotRecipeVariantProps): Pretty<Record<InputGroupSlotRecipeSlot, string>>
   raw: (props?: InputGroupSlotRecipeVariantProps) => InputGroupSlotRecipeVariantProps
   variantMap: InputGroupSlotRecipeVariantMap
   variantKeys: Array<keyof InputGroupSlotRecipeVariant>

package/recipes/input-group-slot-recipe.mjs

@@ -23,6 +23,7 @@ export const inputGroupSlotRecipe = /* @__PURE__ */ Object.assign(inputGroupSlot
   __recipe__: false,
   __name__: 'inputGroupSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: inputGroupSlotRecipeVariantKeys,
   variantMap: {},
   splitVariantProps(props) {

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

@@ -17,13 +17,16 @@ type InputSlotRecipeVariantMap = {
   [key in keyof InputSlotRecipeVariant]: Array<InputSlotRecipeVariant[key]>
 }
 
+type InputSlotRecipeSlot = "root" | "control" | "clear"
+
 export type InputSlotRecipeVariantProps = {
   [key in keyof InputSlotRecipeVariant]?: ConditionalValue<InputSlotRecipeVariant[key]> | undefined
 }
 
 export interface InputSlotRecipeRecipe {
+  __slot: InputSlotRecipeSlot
   __type: InputSlotRecipeVariantProps
-  (props?: InputSlotRecipeVariantProps): Pretty<Record<"root" | "control" | "clear", string>>
+  (props?: InputSlotRecipeVariantProps): Pretty<Record<InputSlotRecipeSlot, string>>
   raw: (props?: InputSlotRecipeVariantProps) => InputSlotRecipeVariantProps
   variantMap: InputSlotRecipeVariantMap
   variantKeys: Array<keyof InputSlotRecipeVariant>

package/recipes/input-slot-recipe.mjs

@@ -37,6 +37,7 @@ export const inputSlotRecipe = /* @__PURE__ */ Object.assign(inputSlotRecipeFn,
   __recipe__: false,
   __name__: 'inputSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: inputSlotRecipeVariantKeys,
   variantMap: {
   "variant": [