@moneyforward/mfui-components 2.48.1

package/dist/esm/styled-system/recipes/month-picker-panel-slot-recipe.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MonthPickerPanelSlotRecipeVariant {
+  
+}
+
+type MonthPickerPanelSlotRecipeVariantMap = {
+  [key in keyof MonthPickerPanelSlotRecipeVariant]: Array<MonthPickerPanelSlotRecipeVariant[key]>
+}
+
+type MonthPickerPanelSlotRecipeSlot = "root" | "navigation" | "grid" | "yearSelector" | "yearNavigationPlaceholder"
+
+export type MonthPickerPanelSlotRecipeVariantProps = {
+  [key in keyof MonthPickerPanelSlotRecipeVariant]?: ConditionalValue<MonthPickerPanelSlotRecipeVariant[key]> | undefined
+}
+
+export interface MonthPickerPanelSlotRecipeRecipe {
+  __slot: MonthPickerPanelSlotRecipeSlot
+  __type: MonthPickerPanelSlotRecipeVariantProps
+  (props?: MonthPickerPanelSlotRecipeVariantProps): Pretty<Record<MonthPickerPanelSlotRecipeSlot, string>>
+  raw: (props?: MonthPickerPanelSlotRecipeVariantProps) => MonthPickerPanelSlotRecipeVariantProps
+  variantMap: MonthPickerPanelSlotRecipeVariantMap
+  variantKeys: Array<keyof MonthPickerPanelSlotRecipeVariant>
+  splitVariantProps<Props extends MonthPickerPanelSlotRecipeVariantProps>(props: Props): [MonthPickerPanelSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MonthPickerPanelSlotRecipeVariantProps>>]
+  getVariantProps: (props?: MonthPickerPanelSlotRecipeVariantProps) => MonthPickerPanelSlotRecipeVariantProps
+}
+
+
+export declare const monthPickerPanelSlotRecipe: MonthPickerPanelSlotRecipeRecipe

package/dist/esm/styled-system/recipes/month-picker-panel-slot-recipe.js

@@ -0,0 +1,44 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const monthPickerPanelSlotRecipeDefaultVariants = {};
+const monthPickerPanelSlotRecipeCompoundVariants = [];
+const monthPickerPanelSlotRecipeSlotNames = [
+    [
+        "root",
+        "MonthPickerPanel__root"
+    ],
+    [
+        "navigation",
+        "MonthPickerPanel__navigation"
+    ],
+    [
+        "grid",
+        "MonthPickerPanel__grid"
+    ],
+    [
+        "yearSelector",
+        "MonthPickerPanel__yearSelector"
+    ],
+    [
+        "yearNavigationPlaceholder",
+        "MonthPickerPanel__yearNavigationPlaceholder"
+    ]
+];
+const monthPickerPanelSlotRecipeSlotFns = /* @__PURE__ */ monthPickerPanelSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, monthPickerPanelSlotRecipeDefaultVariants, getSlotCompoundVariant(monthPickerPanelSlotRecipeCompoundVariants, slotName))]);
+const monthPickerPanelSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(monthPickerPanelSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const monthPickerPanelSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...monthPickerPanelSlotRecipeDefaultVariants, ...compact(variants) });
+export const monthPickerPanelSlotRecipe = /* @__PURE__ */ Object.assign(monthPickerPanelSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'monthPickerPanelSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: monthPickerPanelSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, monthPickerPanelSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/month-range-picker-content-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MonthRangePickerContentSlotRecipeVariant {
+  
+}
+
+type MonthRangePickerContentSlotRecipeVariantMap = {
+  [key in keyof MonthRangePickerContentSlotRecipeVariant]: Array<MonthRangePickerContentSlotRecipeVariant[key]>
+}
+
+type MonthRangePickerContentSlotRecipeSlot = "root"
+
+export type MonthRangePickerContentSlotRecipeVariantProps = {
+  [key in keyof MonthRangePickerContentSlotRecipeVariant]?: ConditionalValue<MonthRangePickerContentSlotRecipeVariant[key]> | undefined
+}
+
+export interface MonthRangePickerContentSlotRecipeRecipe {
+  __slot: MonthRangePickerContentSlotRecipeSlot
+  __type: MonthRangePickerContentSlotRecipeVariantProps
+  (props?: MonthRangePickerContentSlotRecipeVariantProps): Pretty<Record<MonthRangePickerContentSlotRecipeSlot, string>>
+  raw: (props?: MonthRangePickerContentSlotRecipeVariantProps) => MonthRangePickerContentSlotRecipeVariantProps
+  variantMap: MonthRangePickerContentSlotRecipeVariantMap
+  variantKeys: Array<keyof MonthRangePickerContentSlotRecipeVariant>
+  splitVariantProps<Props extends MonthRangePickerContentSlotRecipeVariantProps>(props: Props): [MonthRangePickerContentSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MonthRangePickerContentSlotRecipeVariantProps>>]
+  getVariantProps: (props?: MonthRangePickerContentSlotRecipeVariantProps) => MonthRangePickerContentSlotRecipeVariantProps
+}
+
+/**
+ * The styles for the MonthRangePicker Content component
+ */
+export declare const monthRangePickerContentSlotRecipe: MonthRangePickerContentSlotRecipeRecipe

package/dist/esm/styled-system/recipes/month-range-picker-content-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const monthRangePickerContentSlotRecipeDefaultVariants = {};
+const monthRangePickerContentSlotRecipeCompoundVariants = [];
+const monthRangePickerContentSlotRecipeSlotNames = [
+    [
+        "root",
+        "MonthRangePickerContent__root"
+    ]
+];
+const monthRangePickerContentSlotRecipeSlotFns = /* @__PURE__ */ monthRangePickerContentSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, monthRangePickerContentSlotRecipeDefaultVariants, getSlotCompoundVariant(monthRangePickerContentSlotRecipeCompoundVariants, slotName))]);
+const monthRangePickerContentSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(monthRangePickerContentSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const monthRangePickerContentSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...monthRangePickerContentSlotRecipeDefaultVariants, ...compact(variants) });
+export const monthRangePickerContentSlotRecipe = /* @__PURE__ */ Object.assign(monthRangePickerContentSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'monthRangePickerContentSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: monthRangePickerContentSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, monthRangePickerContentSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/month-range-picker-navigation-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MonthRangePickerNavigationSlotRecipeVariant {
+  
+}
+
+type MonthRangePickerNavigationSlotRecipeVariantMap = {
+  [key in keyof MonthRangePickerNavigationSlotRecipeVariant]: Array<MonthRangePickerNavigationSlotRecipeVariant[key]>
+}
+
+type MonthRangePickerNavigationSlotRecipeSlot = "root" | "column" | "blankIconButton"
+
+export type MonthRangePickerNavigationSlotRecipeVariantProps = {
+  [key in keyof MonthRangePickerNavigationSlotRecipeVariant]?: ConditionalValue<MonthRangePickerNavigationSlotRecipeVariant[key]> | undefined
+}
+
+export interface MonthRangePickerNavigationSlotRecipeRecipe {
+  __slot: MonthRangePickerNavigationSlotRecipeSlot
+  __type: MonthRangePickerNavigationSlotRecipeVariantProps
+  (props?: MonthRangePickerNavigationSlotRecipeVariantProps): Pretty<Record<MonthRangePickerNavigationSlotRecipeSlot, string>>
+  raw: (props?: MonthRangePickerNavigationSlotRecipeVariantProps) => MonthRangePickerNavigationSlotRecipeVariantProps
+  variantMap: MonthRangePickerNavigationSlotRecipeVariantMap
+  variantKeys: Array<keyof MonthRangePickerNavigationSlotRecipeVariant>
+  splitVariantProps<Props extends MonthRangePickerNavigationSlotRecipeVariantProps>(props: Props): [MonthRangePickerNavigationSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MonthRangePickerNavigationSlotRecipeVariantProps>>]
+  getVariantProps: (props?: MonthRangePickerNavigationSlotRecipeVariantProps) => MonthRangePickerNavigationSlotRecipeVariantProps
+}
+
+/**
+ * The styles for the MonthRangePicker Navigation component
+ */
+export declare const monthRangePickerNavigationSlotRecipe: MonthRangePickerNavigationSlotRecipeRecipe

package/dist/esm/styled-system/recipes/month-range-picker-navigation-slot-recipe.js

@@ -0,0 +1,36 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const monthRangePickerNavigationSlotRecipeDefaultVariants = {};
+const monthRangePickerNavigationSlotRecipeCompoundVariants = [];
+const monthRangePickerNavigationSlotRecipeSlotNames = [
+    [
+        "root",
+        "MonthRangePickerNavigation__root"
+    ],
+    [
+        "column",
+        "MonthRangePickerNavigation__column"
+    ],
+    [
+        "blankIconButton",
+        "MonthRangePickerNavigation__blankIconButton"
+    ]
+];
+const monthRangePickerNavigationSlotRecipeSlotFns = /* @__PURE__ */ monthRangePickerNavigationSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, monthRangePickerNavigationSlotRecipeDefaultVariants, getSlotCompoundVariant(monthRangePickerNavigationSlotRecipeCompoundVariants, slotName))]);
+const monthRangePickerNavigationSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(monthRangePickerNavigationSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const monthRangePickerNavigationSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...monthRangePickerNavigationSlotRecipeDefaultVariants, ...compact(variants) });
+export const monthRangePickerNavigationSlotRecipe = /* @__PURE__ */ Object.assign(monthRangePickerNavigationSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'monthRangePickerNavigationSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: monthRangePickerNavigationSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, monthRangePickerNavigationSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/month-range-picker-panel-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MonthRangePickerPanelSlotRecipeVariant {
+  
+}
+
+type MonthRangePickerPanelSlotRecipeVariantMap = {
+  [key in keyof MonthRangePickerPanelSlotRecipeVariant]: Array<MonthRangePickerPanelSlotRecipeVariant[key]>
+}
+
+type MonthRangePickerPanelSlotRecipeSlot = "root"
+
+export type MonthRangePickerPanelSlotRecipeVariantProps = {
+  [key in keyof MonthRangePickerPanelSlotRecipeVariant]?: ConditionalValue<MonthRangePickerPanelSlotRecipeVariant[key]> | undefined
+}
+
+export interface MonthRangePickerPanelSlotRecipeRecipe {
+  __slot: MonthRangePickerPanelSlotRecipeSlot
+  __type: MonthRangePickerPanelSlotRecipeVariantProps
+  (props?: MonthRangePickerPanelSlotRecipeVariantProps): Pretty<Record<MonthRangePickerPanelSlotRecipeSlot, string>>
+  raw: (props?: MonthRangePickerPanelSlotRecipeVariantProps) => MonthRangePickerPanelSlotRecipeVariantProps
+  variantMap: MonthRangePickerPanelSlotRecipeVariantMap
+  variantKeys: Array<keyof MonthRangePickerPanelSlotRecipeVariant>
+  splitVariantProps<Props extends MonthRangePickerPanelSlotRecipeVariantProps>(props: Props): [MonthRangePickerPanelSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MonthRangePickerPanelSlotRecipeVariantProps>>]
+  getVariantProps: (props?: MonthRangePickerPanelSlotRecipeVariantProps) => MonthRangePickerPanelSlotRecipeVariantProps
+}
+
+/**
+ * The styles for the MonthRangePicker Panel component
+ */
+export declare const monthRangePickerPanelSlotRecipe: MonthRangePickerPanelSlotRecipeRecipe

package/dist/esm/styled-system/recipes/month-range-picker-panel-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const monthRangePickerPanelSlotRecipeDefaultVariants = {};
+const monthRangePickerPanelSlotRecipeCompoundVariants = [];
+const monthRangePickerPanelSlotRecipeSlotNames = [
+    [
+        "root",
+        "MonthRangePickerPanel__root"
+    ]
+];
+const monthRangePickerPanelSlotRecipeSlotFns = /* @__PURE__ */ monthRangePickerPanelSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, monthRangePickerPanelSlotRecipeDefaultVariants, getSlotCompoundVariant(monthRangePickerPanelSlotRecipeCompoundVariants, slotName))]);
+const monthRangePickerPanelSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(monthRangePickerPanelSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const monthRangePickerPanelSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...monthRangePickerPanelSlotRecipeDefaultVariants, ...compact(variants) });
+export const monthRangePickerPanelSlotRecipe = /* @__PURE__ */ Object.assign(monthRangePickerPanelSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'monthRangePickerPanelSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: monthRangePickerPanelSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, monthRangePickerPanelSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/multiline-text-box-slot-recipe.d.ts

@@ -0,0 +1,52 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MultilineTextBoxSlotRecipeVariant {
+  /**
+ * @default "medium"
+ */
+size: "small" | "medium" | "large"
+/**
+ * @default false
+ */
+disabled: boolean
+/**
+ * @default false
+ */
+invalid: boolean
+/**
+ * @default false
+ */
+enableAutoResize: boolean
+/**
+ * @default "both"
+ */
+resize: "none" | "vertical" | "horizontal" | "both"
+}
+
+type MultilineTextBoxSlotRecipeVariantMap = {
+  [key in keyof MultilineTextBoxSlotRecipeVariant]: Array<MultilineTextBoxSlotRecipeVariant[key]>
+}
+
+type MultilineTextBoxSlotRecipeSlot = "root"
+
+export type MultilineTextBoxSlotRecipeVariantProps = {
+  [key in keyof MultilineTextBoxSlotRecipeVariant]?: ConditionalValue<MultilineTextBoxSlotRecipeVariant[key]> | undefined
+}
+
+export interface MultilineTextBoxSlotRecipeRecipe {
+  __slot: MultilineTextBoxSlotRecipeSlot
+  __type: MultilineTextBoxSlotRecipeVariantProps
+  (props?: MultilineTextBoxSlotRecipeVariantProps): Pretty<Record<MultilineTextBoxSlotRecipeSlot, string>>
+  raw: (props?: MultilineTextBoxSlotRecipeVariantProps) => MultilineTextBoxSlotRecipeVariantProps
+  variantMap: MultilineTextBoxSlotRecipeVariantMap
+  variantKeys: Array<keyof MultilineTextBoxSlotRecipeVariant>
+  splitVariantProps<Props extends MultilineTextBoxSlotRecipeVariantProps>(props: Props): [MultilineTextBoxSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MultilineTextBoxSlotRecipeVariantProps>>]
+  getVariantProps: (props?: MultilineTextBoxSlotRecipeVariantProps) => MultilineTextBoxSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI MultilineTextBox component.
+ */
+export declare const multilineTextBoxSlotRecipe: MultilineTextBoxSlotRecipeRecipe

package/dist/esm/styled-system/recipes/multiline-text-box-slot-recipe.js

@@ -0,0 +1,64 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const multilineTextBoxSlotRecipeDefaultVariants = {
+    "size": "medium",
+    "disabled": false,
+    "invalid": false,
+    "enableAutoResize": false,
+    "resize": "both"
+};
+const multilineTextBoxSlotRecipeCompoundVariants = [];
+const multilineTextBoxSlotRecipeSlotNames = [
+    [
+        "root",
+        "MultilineTextBox__root"
+    ]
+];
+const multilineTextBoxSlotRecipeSlotFns = /* @__PURE__ */ multilineTextBoxSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, multilineTextBoxSlotRecipeDefaultVariants, getSlotCompoundVariant(multilineTextBoxSlotRecipeCompoundVariants, slotName))]);
+const multilineTextBoxSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(multilineTextBoxSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const multilineTextBoxSlotRecipeVariantKeys = [
+    "size",
+    "disabled",
+    "invalid",
+    "enableAutoResize",
+    "resize"
+];
+const getVariantProps = (variants) => ({ ...multilineTextBoxSlotRecipeDefaultVariants, ...compact(variants) });
+export const multilineTextBoxSlotRecipe = /* @__PURE__ */ Object.assign(multilineTextBoxSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'multilineTextBoxSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: multilineTextBoxSlotRecipeVariantKeys,
+    variantMap: {
+        "size": [
+            "small",
+            "medium",
+            "large"
+        ],
+        "disabled": [
+            "true",
+            "false"
+        ],
+        "invalid": [
+            "true",
+            "false"
+        ],
+        "enableAutoResize": [
+            "true",
+            "false"
+        ],
+        "resize": [
+            "none",
+            "vertical",
+            "horizontal",
+            "both"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, multilineTextBoxSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/multiple-filter-select-box-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MultipleFilterSelectBoxSlotRecipeVariant {
+  
+}
+
+type MultipleFilterSelectBoxSlotRecipeVariantMap = {
+  [key in keyof MultipleFilterSelectBoxSlotRecipeVariant]: Array<MultipleFilterSelectBoxSlotRecipeVariant[key]>
+}
+
+type MultipleFilterSelectBoxSlotRecipeSlot = "triggerWrapper"
+
+export type MultipleFilterSelectBoxSlotRecipeVariantProps = {
+  [key in keyof MultipleFilterSelectBoxSlotRecipeVariant]?: ConditionalValue<MultipleFilterSelectBoxSlotRecipeVariant[key]> | undefined
+}
+
+export interface MultipleFilterSelectBoxSlotRecipeRecipe {
+  __slot: MultipleFilterSelectBoxSlotRecipeSlot
+  __type: MultipleFilterSelectBoxSlotRecipeVariantProps
+  (props?: MultipleFilterSelectBoxSlotRecipeVariantProps): Pretty<Record<MultipleFilterSelectBoxSlotRecipeSlot, string>>
+  raw: (props?: MultipleFilterSelectBoxSlotRecipeVariantProps) => MultipleFilterSelectBoxSlotRecipeVariantProps
+  variantMap: MultipleFilterSelectBoxSlotRecipeVariantMap
+  variantKeys: Array<keyof MultipleFilterSelectBoxSlotRecipeVariant>
+  splitVariantProps<Props extends MultipleFilterSelectBoxSlotRecipeVariantProps>(props: Props): [MultipleFilterSelectBoxSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MultipleFilterSelectBoxSlotRecipeVariantProps>>]
+  getVariantProps: (props?: MultipleFilterSelectBoxSlotRecipeVariantProps) => MultipleFilterSelectBoxSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI MultipleFilterSelectBox component.
+ */
+export declare const multipleFilterSelectBoxSlotRecipe: MultipleFilterSelectBoxSlotRecipeRecipe

package/dist/esm/styled-system/recipes/multiple-filter-select-box-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const multipleFilterSelectBoxSlotRecipeDefaultVariants = {};
+const multipleFilterSelectBoxSlotRecipeCompoundVariants = [];
+const multipleFilterSelectBoxSlotRecipeSlotNames = [
+    [
+        "triggerWrapper",
+        "MultipleFilterSelectBox__triggerWrapper"
+    ]
+];
+const multipleFilterSelectBoxSlotRecipeSlotFns = /* @__PURE__ */ multipleFilterSelectBoxSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, multipleFilterSelectBoxSlotRecipeDefaultVariants, getSlotCompoundVariant(multipleFilterSelectBoxSlotRecipeCompoundVariants, slotName))]);
+const multipleFilterSelectBoxSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(multipleFilterSelectBoxSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const multipleFilterSelectBoxSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...multipleFilterSelectBoxSlotRecipeDefaultVariants, ...compact(variants) });
+export const multipleFilterSelectBoxSlotRecipe = /* @__PURE__ */ Object.assign(multipleFilterSelectBoxSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'multipleFilterSelectBoxSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: multipleFilterSelectBoxSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, multipleFilterSelectBoxSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/multiple-select-box-slot-recipe.d.ts

@@ -0,0 +1,33 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MultipleSelectBoxSlotRecipeVariant {
+  showGroupOptionDivider: boolean
+}
+
+type MultipleSelectBoxSlotRecipeVariantMap = {
+  [key in keyof MultipleSelectBoxSlotRecipeVariant]: Array<MultipleSelectBoxSlotRecipeVariant[key]>
+}
+
+type MultipleSelectBoxSlotRecipeSlot = "popover" | "menuHeader" | "optionPanel" | "listBox" | "listItem" | "skeletonItem" | "emptyMessage" | "menuFooter"
+
+export type MultipleSelectBoxSlotRecipeVariantProps = {
+  [key in keyof MultipleSelectBoxSlotRecipeVariant]?: ConditionalValue<MultipleSelectBoxSlotRecipeVariant[key]> | undefined
+}
+
+export interface MultipleSelectBoxSlotRecipeRecipe {
+  __slot: MultipleSelectBoxSlotRecipeSlot
+  __type: MultipleSelectBoxSlotRecipeVariantProps
+  (props?: MultipleSelectBoxSlotRecipeVariantProps): Pretty<Record<MultipleSelectBoxSlotRecipeSlot, string>>
+  raw: (props?: MultipleSelectBoxSlotRecipeVariantProps) => MultipleSelectBoxSlotRecipeVariantProps
+  variantMap: MultipleSelectBoxSlotRecipeVariantMap
+  variantKeys: Array<keyof MultipleSelectBoxSlotRecipeVariant>
+  splitVariantProps<Props extends MultipleSelectBoxSlotRecipeVariantProps>(props: Props): [MultipleSelectBoxSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MultipleSelectBoxSlotRecipeVariantProps>>]
+  getVariantProps: (props?: MultipleSelectBoxSlotRecipeVariantProps) => MultipleSelectBoxSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI MultipleSelectBox component.
+ */
+export declare const multipleSelectBoxSlotRecipe: MultipleSelectBoxSlotRecipeRecipe

package/dist/esm/styled-system/recipes/multiple-select-box-slot-recipe.js

@@ -0,0 +1,63 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const multipleSelectBoxSlotRecipeDefaultVariants = {};
+const multipleSelectBoxSlotRecipeCompoundVariants = [];
+const multipleSelectBoxSlotRecipeSlotNames = [
+    [
+        "popover",
+        "MultipleSelectBox__popover"
+    ],
+    [
+        "menuHeader",
+        "MultipleSelectBox__menuHeader"
+    ],
+    [
+        "optionPanel",
+        "MultipleSelectBox__optionPanel"
+    ],
+    [
+        "listBox",
+        "MultipleSelectBox__listBox"
+    ],
+    [
+        "listItem",
+        "MultipleSelectBox__listItem"
+    ],
+    [
+        "skeletonItem",
+        "MultipleSelectBox__skeletonItem"
+    ],
+    [
+        "emptyMessage",
+        "MultipleSelectBox__emptyMessage"
+    ],
+    [
+        "menuFooter",
+        "MultipleSelectBox__menuFooter"
+    ]
+];
+const multipleSelectBoxSlotRecipeSlotFns = /* @__PURE__ */ multipleSelectBoxSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, multipleSelectBoxSlotRecipeDefaultVariants, getSlotCompoundVariant(multipleSelectBoxSlotRecipeCompoundVariants, slotName))]);
+const multipleSelectBoxSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(multipleSelectBoxSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const multipleSelectBoxSlotRecipeVariantKeys = [
+    "showGroupOptionDivider"
+];
+const getVariantProps = (variants) => ({ ...multipleSelectBoxSlotRecipeDefaultVariants, ...compact(variants) });
+export const multipleSelectBoxSlotRecipe = /* @__PURE__ */ Object.assign(multipleSelectBoxSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'multipleSelectBoxSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: multipleSelectBoxSlotRecipeVariantKeys,
+    variantMap: {
+        "showGroupOptionDivider": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, multipleSelectBoxSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/multiple-select-box-trigger-recipe.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface MultipleSelectBoxTriggerRecipeVariant {
+  /**
+ * @default "medium"
+ */
+size: "small" | "medium"
+}
+
+type MultipleSelectBoxTriggerRecipeVariantMap = {
+  [key in keyof MultipleSelectBoxTriggerRecipeVariant]: Array<MultipleSelectBoxTriggerRecipeVariant[key]>
+}
+
+type MultipleSelectBoxTriggerRecipeSlot = "wrapper" | "trigger" | "placeholder" | "displayValues" | "label" | "tagList" | "tagItem" | "clearButton" | "clearButtonContainer" | "dropdownIcon" | "dropdownIconContainer"
+
+export type MultipleSelectBoxTriggerRecipeVariantProps = {
+  [key in keyof MultipleSelectBoxTriggerRecipeVariant]?: ConditionalValue<MultipleSelectBoxTriggerRecipeVariant[key]> | undefined
+}
+
+export interface MultipleSelectBoxTriggerRecipeRecipe {
+  __slot: MultipleSelectBoxTriggerRecipeSlot
+  __type: MultipleSelectBoxTriggerRecipeVariantProps
+  (props?: MultipleSelectBoxTriggerRecipeVariantProps): Pretty<Record<MultipleSelectBoxTriggerRecipeSlot, string>>
+  raw: (props?: MultipleSelectBoxTriggerRecipeVariantProps) => MultipleSelectBoxTriggerRecipeVariantProps
+  variantMap: MultipleSelectBoxTriggerRecipeVariantMap
+  variantKeys: Array<keyof MultipleSelectBoxTriggerRecipeVariant>
+  splitVariantProps<Props extends MultipleSelectBoxTriggerRecipeVariantProps>(props: Props): [MultipleSelectBoxTriggerRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof MultipleSelectBoxTriggerRecipeVariantProps>>]
+  getVariantProps: (props?: MultipleSelectBoxTriggerRecipeVariantProps) => MultipleSelectBoxTriggerRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI MultipleSelectBoxTrigger component which used in MultipleSelectBox component.
+ */
+export declare const multipleSelectBoxTriggerRecipe: MultipleSelectBoxTriggerRecipeRecipe