@mekari/pixel3-styled-system 0.1.6 → 0.1.7

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

@@ -10,13 +10,16 @@ type InputTagSlotRecipeVariantMap = {
   [key in keyof InputTagSlotRecipeVariant]: Array<InputTagSlotRecipeVariant[key]>
 }
 
+type InputTagSlotRecipeSlot = "root" | "trigger" | "input" | "content" | "resetButton" | "dropdownButton" | "addButton" | "loading" | "empty" | "suggestionWrapper" | "suggestionLoading"
+
 export type InputTagSlotRecipeVariantProps = {
   [key in keyof InputTagSlotRecipeVariant]?: ConditionalValue<InputTagSlotRecipeVariant[key]> | undefined
 }
 
 export interface InputTagSlotRecipeRecipe {
+  __slot: InputTagSlotRecipeSlot
   __type: InputTagSlotRecipeVariantProps
-  (props?: InputTagSlotRecipeVariantProps): Pretty<Record<"root" | "trigger" | "input" | "content" | "resetButton" | "dropdownButton" | "addButton" | "loading" | "empty" | "suggestionWrapper" | "suggestionLoading", string>>
+  (props?: InputTagSlotRecipeVariantProps): Pretty<Record<InputTagSlotRecipeSlot, string>>
   raw: (props?: InputTagSlotRecipeVariantProps) => InputTagSlotRecipeVariantProps
   variantMap: InputTagSlotRecipeVariantMap
   variantKeys: Array<keyof InputTagSlotRecipeVariant>

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

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

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

@@ -13,13 +13,16 @@ type ModalSlotRecipeVariantMap = {
   [key in keyof ModalSlotRecipeVariant]: Array<ModalSlotRecipeVariant[key]>
 }
 
+type ModalSlotRecipeSlot = "root" | "rootChild" | "body" | "contentRoot" | "contentChild" | "header" | "footer" | "body" | "overlay"
+
 export type ModalSlotRecipeVariantProps = {
   [key in keyof ModalSlotRecipeVariant]?: ConditionalValue<ModalSlotRecipeVariant[key]> | undefined
 }
 
 export interface ModalSlotRecipeRecipe {
+  __slot: ModalSlotRecipeSlot
   __type: ModalSlotRecipeVariantProps
-  (props?: ModalSlotRecipeVariantProps): Pretty<Record<"root" | "rootChild" | "body" | "contentRoot" | "contentChild" | "header" | "footer" | "body" | "overlay", string>>
+  (props?: ModalSlotRecipeVariantProps): Pretty<Record<ModalSlotRecipeSlot, string>>
   raw: (props?: ModalSlotRecipeVariantProps) => ModalSlotRecipeVariantProps
   variantMap: ModalSlotRecipeVariantMap
   variantKeys: Array<keyof ModalSlotRecipeVariant>

package/recipes/modal-slot-recipe.mjs

@@ -59,6 +59,7 @@ export const modalSlotRecipe = /* @__PURE__ */ Object.assign(modalSlotRecipeFn,
   __recipe__: false,
   __name__: 'modalSlotRecipe',
   raw: (props) => props,
+  classNameMap: {},
   variantKeys: modalSlotRecipeVariantKeys,
   variantMap: {
   "full": [

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

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

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

@@ -10,13 +10,16 @@ type PinbarSlotRecipeVariantMap = {
   [key in keyof PinbarSlotRecipeVariant]: Array<PinbarSlotRecipeVariant[key]>
 }
 
+type PinbarSlotRecipeSlot = "root" | "pinbar"
+
 export type PinbarSlotRecipeVariantProps = {
   [key in keyof PinbarSlotRecipeVariant]?: ConditionalValue<PinbarSlotRecipeVariant[key]> | undefined
 }
 
 export interface PinbarSlotRecipeRecipe {
+  __slot: PinbarSlotRecipeSlot
   __type: PinbarSlotRecipeVariantProps
-  (props?: PinbarSlotRecipeVariantProps): Pretty<Record<"root" | "pinbar", string>>
+  (props?: PinbarSlotRecipeVariantProps): Pretty<Record<PinbarSlotRecipeSlot, string>>
   raw: (props?: PinbarSlotRecipeVariantProps) => PinbarSlotRecipeVariantProps
   variantMap: PinbarSlotRecipeVariantMap
   variantKeys: Array<keyof PinbarSlotRecipeVariant>

package/recipes/pinbar-slot-recipe.mjs

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

package/recipes/popover-content-recipe.d.ts

@@ -17,11 +17,14 @@ type PopoverContentRecipeVariantMap = {
   [key in keyof PopoverContentRecipeVariant]: Array<PopoverContentRecipeVariant[key]>
 }
 
+
+
 export type PopoverContentRecipeVariantProps = {
   [key in keyof PopoverContentRecipeVariant]?: ConditionalValue<PopoverContentRecipeVariant[key]> | undefined
 }
 
 export interface PopoverContentRecipeRecipe {
+  
   __type: PopoverContentRecipeVariantProps
   (props?: PopoverContentRecipeVariantProps): string
   raw: (props?: PopoverContentRecipeVariantProps) => PopoverContentRecipeVariantProps

package/recipes/popover-list-item-recipe.d.ts

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

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

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

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

@@ -17,13 +17,16 @@ type ProgressSlotRecipeVariantMap = {
   [key in keyof ProgressSlotRecipeVariant]: Array<ProgressSlotRecipeVariant[key]>
 }
 
+type ProgressSlotRecipeSlot = "root" | "linear" | "circularBase" | "circularTrack"
+
 export type ProgressSlotRecipeVariantProps = {
   [key in keyof ProgressSlotRecipeVariant]?: ConditionalValue<ProgressSlotRecipeVariant[key]> | undefined
 }
 
 export interface ProgressSlotRecipeRecipe {
+  __slot: ProgressSlotRecipeSlot
   __type: ProgressSlotRecipeVariantProps
-  (props?: ProgressSlotRecipeVariantProps): Pretty<Record<"root" | "linear" | "circularBase" | "circularTrack", string>>
+  (props?: ProgressSlotRecipeVariantProps): Pretty<Record<ProgressSlotRecipeSlot, string>>
   raw: (props?: ProgressSlotRecipeVariantProps) => ProgressSlotRecipeVariantProps
   variantMap: ProgressSlotRecipeVariantMap
   variantKeys: Array<keyof ProgressSlotRecipeVariant>

package/recipes/progress-slot-recipe.mjs

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

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

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

package/recipes/radio-slot-recipe.mjs

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

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

@@ -10,13 +10,16 @@ type RatingSlotRecipeVariantMap = {
   [key in keyof RatingSlotRecipeVariant]: Array<RatingSlotRecipeVariant[key]>
 }
 
+type RatingSlotRecipeSlot = "root" | "wrapper" | "value" | "backgroundIconWrapper" | "activeIconWrapper"
+
 export type RatingSlotRecipeVariantProps = {
   [key in keyof RatingSlotRecipeVariant]?: ConditionalValue<RatingSlotRecipeVariant[key]> | undefined
 }
 
 export interface RatingSlotRecipeRecipe {
+  __slot: RatingSlotRecipeSlot
   __type: RatingSlotRecipeVariantProps
-  (props?: RatingSlotRecipeVariantProps): Pretty<Record<"root" | "wrapper" | "value" | "backgroundIconWrapper" | "activeIconWrapper", string>>
+  (props?: RatingSlotRecipeVariantProps): Pretty<Record<RatingSlotRecipeSlot, string>>
   raw: (props?: RatingSlotRecipeVariantProps) => RatingSlotRecipeVariantProps
   variantMap: RatingSlotRecipeVariantMap
   variantKeys: Array<keyof RatingSlotRecipeVariant>

package/recipes/rating-slot-recipe.mjs

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

package/recipes/rich-text-editor-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type RichTextEditorSlotRecipeVariantMap = {
   [key in keyof RichTextEditorSlotRecipeVariant]: Array<RichTextEditorSlotRecipeVariant[key]>
 }
 
+type RichTextEditorSlotRecipeSlot = "root" | "toolbar" | "area"
+
 export type RichTextEditorSlotRecipeVariantProps = {
   [key in keyof RichTextEditorSlotRecipeVariant]?: ConditionalValue<RichTextEditorSlotRecipeVariant[key]> | undefined
 }
 
 export interface RichTextEditorSlotRecipeRecipe {
+  __slot: RichTextEditorSlotRecipeSlot
   __type: RichTextEditorSlotRecipeVariantProps
-  (props?: RichTextEditorSlotRecipeVariantProps): Pretty<Record<"root" | "toolbar" | "area", string>>
+  (props?: RichTextEditorSlotRecipeVariantProps): Pretty<Record<RichTextEditorSlotRecipeSlot, string>>
   raw: (props?: RichTextEditorSlotRecipeVariantProps) => RichTextEditorSlotRecipeVariantProps
   variantMap: RichTextEditorSlotRecipeVariantMap
   variantKeys: Array<keyof RichTextEditorSlotRecipeVariant>

package/recipes/rich-text-editor-slot-recipe.mjs

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

package/recipes/rtestyle-provider-recipe.d.ts

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

package/recipes/scrollbar-recipe.d.ts

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

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

@@ -10,13 +10,16 @@ type SegmentedControlSlotRecipeVariantMap = {
   [key in keyof SegmentedControlSlotRecipeVariant]: Array<SegmentedControlSlotRecipeVariant[key]>
 }
 
+type SegmentedControlSlotRecipeSlot = "root" | "item" | "hidden" | "control" | "label" | "icon"
+
 export type SegmentedControlSlotRecipeVariantProps = {
   [key in keyof SegmentedControlSlotRecipeVariant]?: ConditionalValue<SegmentedControlSlotRecipeVariant[key]> | undefined
 }
 
 export interface SegmentedControlSlotRecipeRecipe {
+  __slot: SegmentedControlSlotRecipeSlot
   __type: SegmentedControlSlotRecipeVariantProps
-  (props?: SegmentedControlSlotRecipeVariantProps): Pretty<Record<"root" | "item" | "hidden" | "control" | "label" | "icon", string>>
+  (props?: SegmentedControlSlotRecipeVariantProps): Pretty<Record<SegmentedControlSlotRecipeSlot, string>>
   raw: (props?: SegmentedControlSlotRecipeVariantProps) => SegmentedControlSlotRecipeVariantProps
   variantMap: SegmentedControlSlotRecipeVariantMap
   variantKeys: Array<keyof SegmentedControlSlotRecipeVariant>

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

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

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

@@ -13,13 +13,16 @@ type SelectSlotRecipeVariantMap = {
   [key in keyof SelectSlotRecipeVariant]: Array<SelectSlotRecipeVariant[key]>
 }
 
+type SelectSlotRecipeSlot = "root" | "control" | "clear" | "arrow"
+
 export type SelectSlotRecipeVariantProps = {
   [key in keyof SelectSlotRecipeVariant]?: ConditionalValue<SelectSlotRecipeVariant[key]> | undefined
 }
 
 export interface SelectSlotRecipeRecipe {
+  __slot: SelectSlotRecipeSlot
   __type: SelectSlotRecipeVariantProps
-  (props?: SelectSlotRecipeVariantProps): Pretty<Record<"root" | "control" | "clear" | "arrow", string>>
+  (props?: SelectSlotRecipeVariantProps): Pretty<Record<SelectSlotRecipeSlot, string>>
   raw: (props?: SelectSlotRecipeVariantProps) => SelectSlotRecipeVariantProps
   variantMap: SelectSlotRecipeVariantMap
   variantKeys: Array<keyof SelectSlotRecipeVariant>

package/recipes/select-slot-recipe.mjs

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

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

@@ -10,13 +10,16 @@ type SharedSlotRecipeVariantMap = {
   [key in keyof SharedSlotRecipeVariant]: Array<SharedSlotRecipeVariant[key]>
 }
 
+type SharedSlotRecipeSlot = "hidden"
+
 export type SharedSlotRecipeVariantProps = {
   [key in keyof SharedSlotRecipeVariant]?: ConditionalValue<SharedSlotRecipeVariant[key]> | undefined
 }
 
 export interface SharedSlotRecipeRecipe {
+  __slot: SharedSlotRecipeSlot
   __type: SharedSlotRecipeVariantProps
-  (props?: SharedSlotRecipeVariantProps): Pretty<Record<"hidden", string>>
+  (props?: SharedSlotRecipeVariantProps): Pretty<Record<SharedSlotRecipeSlot, string>>
   raw: (props?: SharedSlotRecipeVariantProps) => SharedSlotRecipeVariantProps
   variantMap: SharedSlotRecipeVariantMap
   variantKeys: Array<keyof SharedSlotRecipeVariant>

package/recipes/shared-slot-recipe.mjs

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

package/recipes/skeleton-recipe.d.ts

@@ -13,11 +13,14 @@ type SkeletonRecipeVariantMap = {
   [key in keyof SkeletonRecipeVariant]: Array<SkeletonRecipeVariant[key]>
 }
 
+
+
 export type SkeletonRecipeVariantProps = {
   [key in keyof SkeletonRecipeVariant]?: SkeletonRecipeVariant[key] | undefined
 }
 
 export interface SkeletonRecipeRecipe {
+  
   __type: SkeletonRecipeVariantProps
   (props?: SkeletonRecipeVariantProps): string
   raw: (props?: SkeletonRecipeVariantProps) => SkeletonRecipeVariantProps

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

@@ -10,13 +10,16 @@ type SliderSlotRecipeVariantMap = {
   [key in keyof SliderSlotRecipeVariant]: Array<SliderSlotRecipeVariant[key]>
 }
 
+type SliderSlotRecipeSlot = "root" | "labelWrapper" | "sliderWrapper" | "progress" | "slider" | "inputWrapper" | "input" | "legendWrapper"
+
 export type SliderSlotRecipeVariantProps = {
   [key in keyof SliderSlotRecipeVariant]?: ConditionalValue<SliderSlotRecipeVariant[key]> | undefined
 }
 
 export interface SliderSlotRecipeRecipe {
+  __slot: SliderSlotRecipeSlot
   __type: SliderSlotRecipeVariantProps
-  (props?: SliderSlotRecipeVariantProps): Pretty<Record<"root" | "labelWrapper" | "sliderWrapper" | "progress" | "slider" | "inputWrapper" | "input" | "legendWrapper", string>>
+  (props?: SliderSlotRecipeVariantProps): Pretty<Record<SliderSlotRecipeSlot, string>>
   raw: (props?: SliderSlotRecipeVariantProps) => SliderSlotRecipeVariantProps
   variantMap: SliderSlotRecipeVariantMap
   variantKeys: Array<keyof SliderSlotRecipeVariant>

package/recipes/slider-slot-recipe.mjs

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

package/recipes/spinner-recipe.d.ts

@@ -13,11 +13,14 @@ 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

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

@@ -10,13 +10,16 @@ type TabListSlotRecipeVariantMap = {
   [key in keyof TabListSlotRecipeVariant]: Array<TabListSlotRecipeVariant[key]>
 }
 
+type TabListSlotRecipeSlot = "root" | "list"
+
 export type TabListSlotRecipeVariantProps = {
   [key in keyof TabListSlotRecipeVariant]?: ConditionalValue<TabListSlotRecipeVariant[key]> | undefined
 }
 
 export interface TabListSlotRecipeRecipe {
+  __slot: TabListSlotRecipeSlot
   __type: TabListSlotRecipeVariantProps
-  (props?: TabListSlotRecipeVariantProps): Pretty<Record<"root" | "list", string>>
+  (props?: TabListSlotRecipeVariantProps): Pretty<Record<TabListSlotRecipeSlot, string>>
   raw: (props?: TabListSlotRecipeVariantProps) => TabListSlotRecipeVariantProps
   variantMap: TabListSlotRecipeVariantMap
   variantKeys: Array<keyof TabListSlotRecipeVariant>

package/recipes/tab-list-slot-recipe.mjs

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

package/recipes/tab-recipe.d.ts

@@ -17,11 +17,14 @@ 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

package/recipes/tab-selected-border-recipe.d.ts

@@ -17,11 +17,14 @@ type TabSelectedBorderRecipeVariantMap = {
   [key in keyof TabSelectedBorderRecipeVariant]: Array<TabSelectedBorderRecipeVariant[key]>
 }
 
+
+
 export type TabSelectedBorderRecipeVariantProps = {
   [key in keyof TabSelectedBorderRecipeVariant]?: TabSelectedBorderRecipeVariant[key] | undefined
 }
 
 export interface TabSelectedBorderRecipeRecipe {
+  
   __type: TabSelectedBorderRecipeVariantProps
   (props?: TabSelectedBorderRecipeVariantProps): string
   raw: (props?: TabSelectedBorderRecipeVariantProps) => TabSelectedBorderRecipeVariantProps

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

@@ -10,11 +10,14 @@ 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

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

@@ -10,13 +10,16 @@ type TableDateSlotRecipeVariantMap = {
   [key in keyof TableDateSlotRecipeVariant]: Array<TableDateSlotRecipeVariant[key]>
 }
 
+type TableDateSlotRecipeSlot = "headerRoot" | "headerLabel" | "dayWrapper" | "dateItemRoot" | "dateItemWrapper" | "shortcutLabelWrapper"
+
 export type TableDateSlotRecipeVariantProps = {
   [key in keyof TableDateSlotRecipeVariant]?: ConditionalValue<TableDateSlotRecipeVariant[key]> | undefined
 }
 
 export interface TableDateSlotRecipeRecipe {
+  __slot: TableDateSlotRecipeSlot
   __type: TableDateSlotRecipeVariantProps
-  (props?: TableDateSlotRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "dayWrapper" | "dateItemRoot" | "dateItemWrapper" | "shortcutLabelWrapper", string>>
+  (props?: TableDateSlotRecipeVariantProps): Pretty<Record<TableDateSlotRecipeSlot, string>>
   raw: (props?: TableDateSlotRecipeVariantProps) => TableDateSlotRecipeVariantProps
   variantMap: TableDateSlotRecipeVariantMap
   variantKeys: Array<keyof TableDateSlotRecipeVariant>

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

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

package/recipes/table-month-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TableMonthSlotRecipeVariantMap = {
   [key in keyof TableMonthSlotRecipeVariant]: Array<TableMonthSlotRecipeVariant[key]>
 }
 
+type TableMonthSlotRecipeSlot = "headerRoot" | "headerLabel" | "monthItemRoot" | "monthItemWrapper" | "shortcutLabelWrapper"
+
 export type TableMonthSlotRecipeVariantProps = {
   [key in keyof TableMonthSlotRecipeVariant]?: ConditionalValue<TableMonthSlotRecipeVariant[key]> | undefined
 }
 
 export interface TableMonthSlotRecipeRecipe {
+  __slot: TableMonthSlotRecipeSlot
   __type: TableMonthSlotRecipeVariantProps
-  (props?: TableMonthSlotRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "monthItemRoot" | "monthItemWrapper" | "shortcutLabelWrapper", string>>
+  (props?: TableMonthSlotRecipeVariantProps): Pretty<Record<TableMonthSlotRecipeSlot, string>>
   raw: (props?: TableMonthSlotRecipeVariantProps) => TableMonthSlotRecipeVariantProps
   variantMap: TableMonthSlotRecipeVariantMap
   variantKeys: Array<keyof TableMonthSlotRecipeVariant>

package/recipes/table-month-slot-recipe.mjs

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

package/recipes/table-recipe.d.ts

@@ -10,11 +10,14 @@ 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

package/recipes/table-year-slot-recipe.d.ts

@@ -10,13 +10,16 @@ type TableYearSlotRecipeVariantMap = {
   [key in keyof TableYearSlotRecipeVariant]: Array<TableYearSlotRecipeVariant[key]>
 }
 
+type TableYearSlotRecipeSlot = "headerRoot" | "headerLabel" | "yearItemRoot" | "yearItemWrapper" | "shortcutLabelWrapper"
+
 export type TableYearSlotRecipeVariantProps = {
   [key in keyof TableYearSlotRecipeVariant]?: ConditionalValue<TableYearSlotRecipeVariant[key]> | undefined
 }
 
 export interface TableYearSlotRecipeRecipe {
+  __slot: TableYearSlotRecipeSlot
   __type: TableYearSlotRecipeVariantProps
-  (props?: TableYearSlotRecipeVariantProps): Pretty<Record<"headerRoot" | "headerLabel" | "yearItemRoot" | "yearItemWrapper" | "shortcutLabelWrapper", string>>
+  (props?: TableYearSlotRecipeVariantProps): Pretty<Record<TableYearSlotRecipeSlot, string>>
   raw: (props?: TableYearSlotRecipeVariantProps) => TableYearSlotRecipeVariantProps
   variantMap: TableYearSlotRecipeVariantMap
   variantKeys: Array<keyof TableYearSlotRecipeVariant>

package/recipes/table-year-slot-recipe.mjs

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

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

@@ -17,13 +17,16 @@ type TagSlotRecipeVariantMap = {
   [key in keyof TagSlotRecipeVariant]: Array<TagSlotRecipeVariant[key]>
 }
 
+type TagSlotRecipeSlot = "root" | "close"
+
 export type TagSlotRecipeVariantProps = {
   [key in keyof TagSlotRecipeVariant]?: TagSlotRecipeVariant[key] | undefined
 }
 
 export interface TagSlotRecipeRecipe {
+  __slot: TagSlotRecipeSlot
   __type: TagSlotRecipeVariantProps
-  (props?: TagSlotRecipeVariantProps): Pretty<Record<"root" | "close", string>>
+  (props?: TagSlotRecipeVariantProps): Pretty<Record<TagSlotRecipeSlot, string>>
   raw: (props?: TagSlotRecipeVariantProps) => TagSlotRecipeVariantProps
   variantMap: TagSlotRecipeVariantMap
   variantKeys: Array<keyof TagSlotRecipeVariant>