@moneyforward/mfui-components 2.48.1

package/dist/esm/styled-system/recipes/dropdown-menu-container-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dropdownMenuContainerSlotRecipeDefaultVariants = {};
+const dropdownMenuContainerSlotRecipeCompoundVariants = [];
+const dropdownMenuContainerSlotRecipeSlotNames = [
+    [
+        "root",
+        "DropdownMenuContainer__root"
+    ]
+];
+const dropdownMenuContainerSlotRecipeSlotFns = /* @__PURE__ */ dropdownMenuContainerSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropdownMenuContainerSlotRecipeDefaultVariants, getSlotCompoundVariant(dropdownMenuContainerSlotRecipeCompoundVariants, slotName))]);
+const dropdownMenuContainerSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dropdownMenuContainerSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dropdownMenuContainerSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dropdownMenuContainerSlotRecipeDefaultVariants, ...compact(variants) });
+export const dropdownMenuContainerSlotRecipe = /* @__PURE__ */ Object.assign(dropdownMenuContainerSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dropdownMenuContainerSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dropdownMenuContainerSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, dropdownMenuContainerSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/dropdown-menu-divider-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 DropdownMenuDividerSlotRecipeVariant {
+  
+}
+
+type DropdownMenuDividerSlotRecipeVariantMap = {
+  [key in keyof DropdownMenuDividerSlotRecipeVariant]: Array<DropdownMenuDividerSlotRecipeVariant[key]>
+}
+
+type DropdownMenuDividerSlotRecipeSlot = "root"
+
+export type DropdownMenuDividerSlotRecipeVariantProps = {
+  [key in keyof DropdownMenuDividerSlotRecipeVariant]?: ConditionalValue<DropdownMenuDividerSlotRecipeVariant[key]> | undefined
+}
+
+export interface DropdownMenuDividerSlotRecipeRecipe {
+  __slot: DropdownMenuDividerSlotRecipeSlot
+  __type: DropdownMenuDividerSlotRecipeVariantProps
+  (props?: DropdownMenuDividerSlotRecipeVariantProps): Pretty<Record<DropdownMenuDividerSlotRecipeSlot, string>>
+  raw: (props?: DropdownMenuDividerSlotRecipeVariantProps) => DropdownMenuDividerSlotRecipeVariantProps
+  variantMap: DropdownMenuDividerSlotRecipeVariantMap
+  variantKeys: Array<keyof DropdownMenuDividerSlotRecipeVariant>
+  splitVariantProps<Props extends DropdownMenuDividerSlotRecipeVariantProps>(props: Props): [DropdownMenuDividerSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DropdownMenuDividerSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DropdownMenuDividerSlotRecipeVariantProps) => DropdownMenuDividerSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DropdownMenuDivider component.
+ */
+export declare const dropdownMenuDividerSlotRecipe: DropdownMenuDividerSlotRecipeRecipe

package/dist/esm/styled-system/recipes/dropdown-menu-divider-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dropdownMenuDividerSlotRecipeDefaultVariants = {};
+const dropdownMenuDividerSlotRecipeCompoundVariants = [];
+const dropdownMenuDividerSlotRecipeSlotNames = [
+    [
+        "root",
+        "DropdownMenuDivider__root"
+    ]
+];
+const dropdownMenuDividerSlotRecipeSlotFns = /* @__PURE__ */ dropdownMenuDividerSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropdownMenuDividerSlotRecipeDefaultVariants, getSlotCompoundVariant(dropdownMenuDividerSlotRecipeCompoundVariants, slotName))]);
+const dropdownMenuDividerSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dropdownMenuDividerSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dropdownMenuDividerSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dropdownMenuDividerSlotRecipeDefaultVariants, ...compact(variants) });
+export const dropdownMenuDividerSlotRecipe = /* @__PURE__ */ Object.assign(dropdownMenuDividerSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dropdownMenuDividerSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dropdownMenuDividerSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, dropdownMenuDividerSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/dropdown-menu-heading-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 DropdownMenuHeadingSlotRecipeVariant {
+  
+}
+
+type DropdownMenuHeadingSlotRecipeVariantMap = {
+  [key in keyof DropdownMenuHeadingSlotRecipeVariant]: Array<DropdownMenuHeadingSlotRecipeVariant[key]>
+}
+
+type DropdownMenuHeadingSlotRecipeSlot = "root"
+
+export type DropdownMenuHeadingSlotRecipeVariantProps = {
+  [key in keyof DropdownMenuHeadingSlotRecipeVariant]?: ConditionalValue<DropdownMenuHeadingSlotRecipeVariant[key]> | undefined
+}
+
+export interface DropdownMenuHeadingSlotRecipeRecipe {
+  __slot: DropdownMenuHeadingSlotRecipeSlot
+  __type: DropdownMenuHeadingSlotRecipeVariantProps
+  (props?: DropdownMenuHeadingSlotRecipeVariantProps): Pretty<Record<DropdownMenuHeadingSlotRecipeSlot, string>>
+  raw: (props?: DropdownMenuHeadingSlotRecipeVariantProps) => DropdownMenuHeadingSlotRecipeVariantProps
+  variantMap: DropdownMenuHeadingSlotRecipeVariantMap
+  variantKeys: Array<keyof DropdownMenuHeadingSlotRecipeVariant>
+  splitVariantProps<Props extends DropdownMenuHeadingSlotRecipeVariantProps>(props: Props): [DropdownMenuHeadingSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DropdownMenuHeadingSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DropdownMenuHeadingSlotRecipeVariantProps) => DropdownMenuHeadingSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DropdownMenuHeading component.
+ */
+export declare const dropdownMenuHeadingSlotRecipe: DropdownMenuHeadingSlotRecipeRecipe

package/dist/esm/styled-system/recipes/dropdown-menu-heading-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dropdownMenuHeadingSlotRecipeDefaultVariants = {};
+const dropdownMenuHeadingSlotRecipeCompoundVariants = [];
+const dropdownMenuHeadingSlotRecipeSlotNames = [
+    [
+        "root",
+        "DropdownMenuHeading__root"
+    ]
+];
+const dropdownMenuHeadingSlotRecipeSlotFns = /* @__PURE__ */ dropdownMenuHeadingSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropdownMenuHeadingSlotRecipeDefaultVariants, getSlotCompoundVariant(dropdownMenuHeadingSlotRecipeCompoundVariants, slotName))]);
+const dropdownMenuHeadingSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dropdownMenuHeadingSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dropdownMenuHeadingSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dropdownMenuHeadingSlotRecipeDefaultVariants, ...compact(variants) });
+export const dropdownMenuHeadingSlotRecipe = /* @__PURE__ */ Object.assign(dropdownMenuHeadingSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dropdownMenuHeadingSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dropdownMenuHeadingSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, dropdownMenuHeadingSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/dropdown-menu-item-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 DropdownMenuItemSlotRecipeVariant {
+  
+}
+
+type DropdownMenuItemSlotRecipeVariantMap = {
+  [key in keyof DropdownMenuItemSlotRecipeVariant]: Array<DropdownMenuItemSlotRecipeVariant[key]>
+}
+
+type DropdownMenuItemSlotRecipeSlot = "root"
+
+export type DropdownMenuItemSlotRecipeVariantProps = {
+  [key in keyof DropdownMenuItemSlotRecipeVariant]?: ConditionalValue<DropdownMenuItemSlotRecipeVariant[key]> | undefined
+}
+
+export interface DropdownMenuItemSlotRecipeRecipe {
+  __slot: DropdownMenuItemSlotRecipeSlot
+  __type: DropdownMenuItemSlotRecipeVariantProps
+  (props?: DropdownMenuItemSlotRecipeVariantProps): Pretty<Record<DropdownMenuItemSlotRecipeSlot, string>>
+  raw: (props?: DropdownMenuItemSlotRecipeVariantProps) => DropdownMenuItemSlotRecipeVariantProps
+  variantMap: DropdownMenuItemSlotRecipeVariantMap
+  variantKeys: Array<keyof DropdownMenuItemSlotRecipeVariant>
+  splitVariantProps<Props extends DropdownMenuItemSlotRecipeVariantProps>(props: Props): [DropdownMenuItemSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DropdownMenuItemSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DropdownMenuItemSlotRecipeVariantProps) => DropdownMenuItemSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DropdownMenuItem component.
+ */
+export declare const dropdownMenuItemSlotRecipe: DropdownMenuItemSlotRecipeRecipe

package/dist/esm/styled-system/recipes/dropdown-menu-item-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dropdownMenuItemSlotRecipeDefaultVariants = {};
+const dropdownMenuItemSlotRecipeCompoundVariants = [];
+const dropdownMenuItemSlotRecipeSlotNames = [
+    [
+        "root",
+        "DropdownMenuItem__root"
+    ]
+];
+const dropdownMenuItemSlotRecipeSlotFns = /* @__PURE__ */ dropdownMenuItemSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropdownMenuItemSlotRecipeDefaultVariants, getSlotCompoundVariant(dropdownMenuItemSlotRecipeCompoundVariants, slotName))]);
+const dropdownMenuItemSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dropdownMenuItemSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dropdownMenuItemSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dropdownMenuItemSlotRecipeDefaultVariants, ...compact(variants) });
+export const dropdownMenuItemSlotRecipe = /* @__PURE__ */ Object.assign(dropdownMenuItemSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dropdownMenuItemSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dropdownMenuItemSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, dropdownMenuItemSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/dropdown-menu-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 DropdownMenuSlotRecipeVariant {
+  
+}
+
+type DropdownMenuSlotRecipeVariantMap = {
+  [key in keyof DropdownMenuSlotRecipeVariant]: Array<DropdownMenuSlotRecipeVariant[key]>
+}
+
+type DropdownMenuSlotRecipeSlot = "popover"
+
+export type DropdownMenuSlotRecipeVariantProps = {
+  [key in keyof DropdownMenuSlotRecipeVariant]?: ConditionalValue<DropdownMenuSlotRecipeVariant[key]> | undefined
+}
+
+export interface DropdownMenuSlotRecipeRecipe {
+  __slot: DropdownMenuSlotRecipeSlot
+  __type: DropdownMenuSlotRecipeVariantProps
+  (props?: DropdownMenuSlotRecipeVariantProps): Pretty<Record<DropdownMenuSlotRecipeSlot, string>>
+  raw: (props?: DropdownMenuSlotRecipeVariantProps) => DropdownMenuSlotRecipeVariantProps
+  variantMap: DropdownMenuSlotRecipeVariantMap
+  variantKeys: Array<keyof DropdownMenuSlotRecipeVariant>
+  splitVariantProps<Props extends DropdownMenuSlotRecipeVariantProps>(props: Props): [DropdownMenuSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DropdownMenuSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DropdownMenuSlotRecipeVariantProps) => DropdownMenuSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DropdownMenu component.
+ */
+export declare const dropdownMenuSlotRecipe: DropdownMenuSlotRecipeRecipe

package/dist/esm/styled-system/recipes/dropdown-menu-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const dropdownMenuSlotRecipeDefaultVariants = {};
+const dropdownMenuSlotRecipeCompoundVariants = [];
+const dropdownMenuSlotRecipeSlotNames = [
+    [
+        "popover",
+        "DropdownMenu__popover"
+    ]
+];
+const dropdownMenuSlotRecipeSlotFns = /* @__PURE__ */ dropdownMenuSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, dropdownMenuSlotRecipeDefaultVariants, getSlotCompoundVariant(dropdownMenuSlotRecipeCompoundVariants, slotName))]);
+const dropdownMenuSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(dropdownMenuSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const dropdownMenuSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...dropdownMenuSlotRecipeDefaultVariants, ...compact(variants) });
+export const dropdownMenuSlotRecipe = /* @__PURE__ */ Object.assign(dropdownMenuSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'dropdownMenuSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: dropdownMenuSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, dropdownMenuSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/embedded-side-pane-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 EmbeddedSidePaneSlotRecipeVariant {
+  
+}
+
+type EmbeddedSidePaneSlotRecipeVariantMap = {
+  [key in keyof EmbeddedSidePaneSlotRecipeVariant]: Array<EmbeddedSidePaneSlotRecipeVariant[key]>
+}
+
+type EmbeddedSidePaneSlotRecipeSlot = "root" | "container"
+
+export type EmbeddedSidePaneSlotRecipeVariantProps = {
+  [key in keyof EmbeddedSidePaneSlotRecipeVariant]?: ConditionalValue<EmbeddedSidePaneSlotRecipeVariant[key]> | undefined
+}
+
+export interface EmbeddedSidePaneSlotRecipeRecipe {
+  __slot: EmbeddedSidePaneSlotRecipeSlot
+  __type: EmbeddedSidePaneSlotRecipeVariantProps
+  (props?: EmbeddedSidePaneSlotRecipeVariantProps): Pretty<Record<EmbeddedSidePaneSlotRecipeSlot, string>>
+  raw: (props?: EmbeddedSidePaneSlotRecipeVariantProps) => EmbeddedSidePaneSlotRecipeVariantProps
+  variantMap: EmbeddedSidePaneSlotRecipeVariantMap
+  variantKeys: Array<keyof EmbeddedSidePaneSlotRecipeVariant>
+  splitVariantProps<Props extends EmbeddedSidePaneSlotRecipeVariantProps>(props: Props): [EmbeddedSidePaneSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof EmbeddedSidePaneSlotRecipeVariantProps>>]
+  getVariantProps: (props?: EmbeddedSidePaneSlotRecipeVariantProps) => EmbeddedSidePaneSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI EmbeddedSidePane component.
+ */
+export declare const embeddedSidePaneSlotRecipe: EmbeddedSidePaneSlotRecipeRecipe

package/dist/esm/styled-system/recipes/embedded-side-pane-slot-recipe.js

@@ -0,0 +1,32 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const embeddedSidePaneSlotRecipeDefaultVariants = {};
+const embeddedSidePaneSlotRecipeCompoundVariants = [];
+const embeddedSidePaneSlotRecipeSlotNames = [
+    [
+        "root",
+        "EmbeddedSidePane__root"
+    ],
+    [
+        "container",
+        "EmbeddedSidePane__container"
+    ]
+];
+const embeddedSidePaneSlotRecipeSlotFns = /* @__PURE__ */ embeddedSidePaneSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, embeddedSidePaneSlotRecipeDefaultVariants, getSlotCompoundVariant(embeddedSidePaneSlotRecipeCompoundVariants, slotName))]);
+const embeddedSidePaneSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(embeddedSidePaneSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const embeddedSidePaneSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...embeddedSidePaneSlotRecipeDefaultVariants, ...compact(variants) });
+export const embeddedSidePaneSlotRecipe = /* @__PURE__ */ Object.assign(embeddedSidePaneSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'embeddedSidePaneSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: embeddedSidePaneSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, embeddedSidePaneSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

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

@@ -0,0 +1,40 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FileBoxSlotRecipeVariant {
+  /**
+ * @default false
+ */
+invalid: boolean
+/**
+ * @default false
+ */
+isDragging: boolean
+}
+
+type FileBoxSlotRecipeVariantMap = {
+  [key in keyof FileBoxSlotRecipeVariant]: Array<FileBoxSlotRecipeVariant[key]>
+}
+
+type FileBoxSlotRecipeSlot = "root" | "input" | "inputBackground" | "container" | "fileInfo" | "button" | "span" | "clearButton"
+
+export type FileBoxSlotRecipeVariantProps = {
+  [key in keyof FileBoxSlotRecipeVariant]?: FileBoxSlotRecipeVariant[key] | undefined
+}
+
+export interface FileBoxSlotRecipeRecipe {
+  __slot: FileBoxSlotRecipeSlot
+  __type: FileBoxSlotRecipeVariantProps
+  (props?: FileBoxSlotRecipeVariantProps): Pretty<Record<FileBoxSlotRecipeSlot, string>>
+  raw: (props?: FileBoxSlotRecipeVariantProps) => FileBoxSlotRecipeVariantProps
+  variantMap: FileBoxSlotRecipeVariantMap
+  variantKeys: Array<keyof FileBoxSlotRecipeVariant>
+  splitVariantProps<Props extends FileBoxSlotRecipeVariantProps>(props: Props): [FileBoxSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof FileBoxSlotRecipeVariantProps>>]
+  getVariantProps: (props?: FileBoxSlotRecipeVariantProps) => FileBoxSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI FileBox component.
+ */
+export declare const fileBoxSlotRecipe: FileBoxSlotRecipeRecipe

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

@@ -0,0 +1,90 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const fileBoxSlotRecipeDefaultVariants = {
+    "invalid": false,
+    "isDragging": false
+};
+const fileBoxSlotRecipeCompoundVariants = [
+    {
+        "invalid": true,
+        "isDragging": true,
+        "css": {
+            "button": {
+                "borderColor": "mfui.color.signal-red.border.pressed"
+            },
+            "input": {
+                "_hover": {
+                    "_notDisabled": {
+                        "& ~ [data-mfui-content=\"filebox-container\"] [data-mfui-content=\"filebox-button\"]": {
+                            "borderColor": "mfui.color.signal-red.border.pressed"
+                        }
+                    }
+                }
+            }
+        }
+    }
+];
+const fileBoxSlotRecipeSlotNames = [
+    [
+        "root",
+        "FileBox__root"
+    ],
+    [
+        "input",
+        "FileBox__input"
+    ],
+    [
+        "inputBackground",
+        "FileBox__inputBackground"
+    ],
+    [
+        "container",
+        "FileBox__container"
+    ],
+    [
+        "fileInfo",
+        "FileBox__fileInfo"
+    ],
+    [
+        "button",
+        "FileBox__button"
+    ],
+    [
+        "span",
+        "FileBox__span"
+    ],
+    [
+        "clearButton",
+        "FileBox__clearButton"
+    ]
+];
+const fileBoxSlotRecipeSlotFns = /* @__PURE__ */ fileBoxSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, fileBoxSlotRecipeDefaultVariants, getSlotCompoundVariant(fileBoxSlotRecipeCompoundVariants, slotName))]);
+const fileBoxSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(fileBoxSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const fileBoxSlotRecipeVariantKeys = [
+    "invalid",
+    "isDragging"
+];
+const getVariantProps = (variants) => ({ ...fileBoxSlotRecipeDefaultVariants, ...compact(variants) });
+export const fileBoxSlotRecipe = /* @__PURE__ */ Object.assign(fileBoxSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'fileBoxSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: fileBoxSlotRecipeVariantKeys,
+    variantMap: {
+        "invalid": [
+            "true",
+            "false"
+        ],
+        "isDragging": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, fileBoxSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/file-drop-zone-slot-recipe.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface FileDropZoneSlotRecipeVariant {
+  /**
+ * @default false
+ */
+invalid: boolean
+/**
+ * @default false
+ */
+isDragging: boolean
+}
+
+type FileDropZoneSlotRecipeVariantMap = {
+  [key in keyof FileDropZoneSlotRecipeVariant]: Array<FileDropZoneSlotRecipeVariant[key]>
+}
+
+type FileDropZoneSlotRecipeSlot = "root" | "input" | "container" | "illustration" | "mainContainer" | "instruction" | "buttonContainer" | "button" | "fileInfo" | "span" | "clearButton" | "helpMessage" | "extra" | "phrase"
+
+export type FileDropZoneSlotRecipeVariantProps = {
+  [key in keyof FileDropZoneSlotRecipeVariant]?: FileDropZoneSlotRecipeVariant[key] | undefined
+}
+
+export interface FileDropZoneSlotRecipeRecipe {
+  __slot: FileDropZoneSlotRecipeSlot
+  __type: FileDropZoneSlotRecipeVariantProps
+  (props?: FileDropZoneSlotRecipeVariantProps): Pretty<Record<FileDropZoneSlotRecipeSlot, string>>
+  raw: (props?: FileDropZoneSlotRecipeVariantProps) => FileDropZoneSlotRecipeVariantProps
+  variantMap: FileDropZoneSlotRecipeVariantMap
+  variantKeys: Array<keyof FileDropZoneSlotRecipeVariant>
+  splitVariantProps<Props extends FileDropZoneSlotRecipeVariantProps>(props: Props): [FileDropZoneSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof FileDropZoneSlotRecipeVariantProps>>]
+  getVariantProps: (props?: FileDropZoneSlotRecipeVariantProps) => FileDropZoneSlotRecipeVariantProps
+}
+
+
+export declare const fileDropZoneSlotRecipe: FileDropZoneSlotRecipeRecipe

package/dist/esm/styled-system/recipes/file-drop-zone-slot-recipe.js

@@ -0,0 +1,105 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const fileDropZoneSlotRecipeDefaultVariants = {
+    "invalid": false,
+    "isDragging": false
+};
+const fileDropZoneSlotRecipeCompoundVariants = [
+    {
+        "invalid": true,
+        "isDragging": true,
+        "css": {
+            "button": {
+                "borderColor": "mfui.color.signal-red.border.pressed"
+            }
+        }
+    }
+];
+const fileDropZoneSlotRecipeSlotNames = [
+    [
+        "root",
+        "file-drop-zone__root"
+    ],
+    [
+        "input",
+        "file-drop-zone__input"
+    ],
+    [
+        "container",
+        "file-drop-zone__container"
+    ],
+    [
+        "illustration",
+        "file-drop-zone__illustration"
+    ],
+    [
+        "mainContainer",
+        "file-drop-zone__mainContainer"
+    ],
+    [
+        "instruction",
+        "file-drop-zone__instruction"
+    ],
+    [
+        "buttonContainer",
+        "file-drop-zone__buttonContainer"
+    ],
+    [
+        "button",
+        "file-drop-zone__button"
+    ],
+    [
+        "fileInfo",
+        "file-drop-zone__fileInfo"
+    ],
+    [
+        "span",
+        "file-drop-zone__span"
+    ],
+    [
+        "clearButton",
+        "file-drop-zone__clearButton"
+    ],
+    [
+        "helpMessage",
+        "file-drop-zone__helpMessage"
+    ],
+    [
+        "extra",
+        "file-drop-zone__extra"
+    ],
+    [
+        "phrase",
+        "file-drop-zone__phrase"
+    ]
+];
+const fileDropZoneSlotRecipeSlotFns = /* @__PURE__ */ fileDropZoneSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, fileDropZoneSlotRecipeDefaultVariants, getSlotCompoundVariant(fileDropZoneSlotRecipeCompoundVariants, slotName))]);
+const fileDropZoneSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(fileDropZoneSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const fileDropZoneSlotRecipeVariantKeys = [
+    "invalid",
+    "isDragging"
+];
+const getVariantProps = (variants) => ({ ...fileDropZoneSlotRecipeDefaultVariants, ...compact(variants) });
+export const fileDropZoneSlotRecipe = /* @__PURE__ */ Object.assign(fileDropZoneSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'fileDropZoneSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: fileDropZoneSlotRecipeVariantKeys,
+    variantMap: {
+        "invalid": [
+            "true",
+            "false"
+        ],
+        "isDragging": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, fileDropZoneSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/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 FilterSelectBoxSlotRecipeVariant {
+  
+}
+
+type FilterSelectBoxSlotRecipeVariantMap = {
+  [key in keyof FilterSelectBoxSlotRecipeVariant]: Array<FilterSelectBoxSlotRecipeVariant[key]>
+}
+
+type FilterSelectBoxSlotRecipeSlot = "trigger" | "selectedText" | "text"
+
+export type FilterSelectBoxSlotRecipeVariantProps = {
+  [key in keyof FilterSelectBoxSlotRecipeVariant]?: ConditionalValue<FilterSelectBoxSlotRecipeVariant[key]> | undefined
+}
+
+export interface FilterSelectBoxSlotRecipeRecipe {
+  __slot: FilterSelectBoxSlotRecipeSlot
+  __type: FilterSelectBoxSlotRecipeVariantProps
+  (props?: FilterSelectBoxSlotRecipeVariantProps): Pretty<Record<FilterSelectBoxSlotRecipeSlot, string>>
+  raw: (props?: FilterSelectBoxSlotRecipeVariantProps) => FilterSelectBoxSlotRecipeVariantProps
+  variantMap: FilterSelectBoxSlotRecipeVariantMap
+  variantKeys: Array<keyof FilterSelectBoxSlotRecipeVariant>
+  splitVariantProps<Props extends FilterSelectBoxSlotRecipeVariantProps>(props: Props): [FilterSelectBoxSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof FilterSelectBoxSlotRecipeVariantProps>>]
+  getVariantProps: (props?: FilterSelectBoxSlotRecipeVariantProps) => FilterSelectBoxSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI FilterSelectBox component.
+ */
+export declare const filterSelectBoxSlotRecipe: FilterSelectBoxSlotRecipeRecipe