@moneyforward/mfui-components 2.48.1

package/dist/esm/styled-system/recipes/disclosure-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 DisclosureSlotRecipeVariant {
+  
+}
+
+type DisclosureSlotRecipeVariantMap = {
+  [key in keyof DisclosureSlotRecipeVariant]: Array<DisclosureSlotRecipeVariant[key]>
+}
+
+type DisclosureSlotRecipeSlot = "trigger" | "target"
+
+export type DisclosureSlotRecipeVariantProps = {
+  [key in keyof DisclosureSlotRecipeVariant]?: ConditionalValue<DisclosureSlotRecipeVariant[key]> | undefined
+}
+
+export interface DisclosureSlotRecipeRecipe {
+  __slot: DisclosureSlotRecipeSlot
+  __type: DisclosureSlotRecipeVariantProps
+  (props?: DisclosureSlotRecipeVariantProps): Pretty<Record<DisclosureSlotRecipeSlot, string>>
+  raw: (props?: DisclosureSlotRecipeVariantProps) => DisclosureSlotRecipeVariantProps
+  variantMap: DisclosureSlotRecipeVariantMap
+  variantKeys: Array<keyof DisclosureSlotRecipeVariant>
+  splitVariantProps<Props extends DisclosureSlotRecipeVariantProps>(props: Props): [DisclosureSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisclosureSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisclosureSlotRecipeVariantProps) => DisclosureSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI Disclosure component.
+ */
+export declare const disclosureSlotRecipe: DisclosureSlotRecipeRecipe

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

@@ -0,0 +1,32 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const disclosureSlotRecipeDefaultVariants = {};
+const disclosureSlotRecipeCompoundVariants = [];
+const disclosureSlotRecipeSlotNames = [
+    [
+        "trigger",
+        "Disclosure__trigger"
+    ],
+    [
+        "target",
+        "Disclosure__target"
+    ]
+];
+const disclosureSlotRecipeSlotFns = /* @__PURE__ */ disclosureSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, disclosureSlotRecipeDefaultVariants, getSlotCompoundVariant(disclosureSlotRecipeCompoundVariants, slotName))]);
+const disclosureSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(disclosureSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const disclosureSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...disclosureSlotRecipeDefaultVariants, ...compact(variants) });
+export const disclosureSlotRecipe = /* @__PURE__ */ Object.assign(disclosureSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'disclosureSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: disclosureSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, disclosureSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/display-table-body-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 DisplayTableBodySlotRecipeVariant {
+  
+}
+
+type DisplayTableBodySlotRecipeVariantMap = {
+  [key in keyof DisplayTableBodySlotRecipeVariant]: Array<DisplayTableBodySlotRecipeVariant[key]>
+}
+
+type DisplayTableBodySlotRecipeSlot = "root"
+
+export type DisplayTableBodySlotRecipeVariantProps = {
+  [key in keyof DisplayTableBodySlotRecipeVariant]?: ConditionalValue<DisplayTableBodySlotRecipeVariant[key]> | undefined
+}
+
+export interface DisplayTableBodySlotRecipeRecipe {
+  __slot: DisplayTableBodySlotRecipeSlot
+  __type: DisplayTableBodySlotRecipeVariantProps
+  (props?: DisplayTableBodySlotRecipeVariantProps): Pretty<Record<DisplayTableBodySlotRecipeSlot, string>>
+  raw: (props?: DisplayTableBodySlotRecipeVariantProps) => DisplayTableBodySlotRecipeVariantProps
+  variantMap: DisplayTableBodySlotRecipeVariantMap
+  variantKeys: Array<keyof DisplayTableBodySlotRecipeVariant>
+  splitVariantProps<Props extends DisplayTableBodySlotRecipeVariantProps>(props: Props): [DisplayTableBodySlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisplayTableBodySlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisplayTableBodySlotRecipeVariantProps) => DisplayTableBodySlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DisplayTableBody component.
+ */
+export declare const displayTableBodySlotRecipe: DisplayTableBodySlotRecipeRecipe

package/dist/esm/styled-system/recipes/display-table-body-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const displayTableBodySlotRecipeDefaultVariants = {};
+const displayTableBodySlotRecipeCompoundVariants = [];
+const displayTableBodySlotRecipeSlotNames = [
+    [
+        "root",
+        "DisplayTableBody__root"
+    ]
+];
+const displayTableBodySlotRecipeSlotFns = /* @__PURE__ */ displayTableBodySlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, displayTableBodySlotRecipeDefaultVariants, getSlotCompoundVariant(displayTableBodySlotRecipeCompoundVariants, slotName))]);
+const displayTableBodySlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(displayTableBodySlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const displayTableBodySlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...displayTableBodySlotRecipeDefaultVariants, ...compact(variants) });
+export const displayTableBodySlotRecipe = /* @__PURE__ */ Object.assign(displayTableBodySlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'displayTableBodySlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: displayTableBodySlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, displayTableBodySlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/display-table-cell-slot-recipe.d.ts

@@ -0,0 +1,36 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DisplayTableCellSlotRecipeVariant {
+  type: "text" | "amount"
+depth: "0" | "1" | "2" | "3" | "4" | "5"
+fixedColumn: boolean
+edgeFixedColumn: "left" | "right"
+}
+
+type DisplayTableCellSlotRecipeVariantMap = {
+  [key in keyof DisplayTableCellSlotRecipeVariant]: Array<DisplayTableCellSlotRecipeVariant[key]>
+}
+
+type DisplayTableCellSlotRecipeSlot = "root" | "content" | "depthSpacing"
+
+export type DisplayTableCellSlotRecipeVariantProps = {
+  [key in keyof DisplayTableCellSlotRecipeVariant]?: ConditionalValue<DisplayTableCellSlotRecipeVariant[key]> | undefined
+}
+
+export interface DisplayTableCellSlotRecipeRecipe {
+  __slot: DisplayTableCellSlotRecipeSlot
+  __type: DisplayTableCellSlotRecipeVariantProps
+  (props?: DisplayTableCellSlotRecipeVariantProps): Pretty<Record<DisplayTableCellSlotRecipeSlot, string>>
+  raw: (props?: DisplayTableCellSlotRecipeVariantProps) => DisplayTableCellSlotRecipeVariantProps
+  variantMap: DisplayTableCellSlotRecipeVariantMap
+  variantKeys: Array<keyof DisplayTableCellSlotRecipeVariant>
+  splitVariantProps<Props extends DisplayTableCellSlotRecipeVariantProps>(props: Props): [DisplayTableCellSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisplayTableCellSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisplayTableCellSlotRecipeVariantProps) => DisplayTableCellSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DisplayTableCell component.
+ */
+export declare const displayTableCellSlotRecipe: DisplayTableCellSlotRecipeRecipe

package/dist/esm/styled-system/recipes/display-table-cell-slot-recipe.js

@@ -0,0 +1,61 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const displayTableCellSlotRecipeDefaultVariants = {};
+const displayTableCellSlotRecipeCompoundVariants = [];
+const displayTableCellSlotRecipeSlotNames = [
+    [
+        "root",
+        "DisplayTableCell__root"
+    ],
+    [
+        "content",
+        "DisplayTableCell__content"
+    ],
+    [
+        "depthSpacing",
+        "DisplayTableCell__depthSpacing"
+    ]
+];
+const displayTableCellSlotRecipeSlotFns = /* @__PURE__ */ displayTableCellSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, displayTableCellSlotRecipeDefaultVariants, getSlotCompoundVariant(displayTableCellSlotRecipeCompoundVariants, slotName))]);
+const displayTableCellSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(displayTableCellSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const displayTableCellSlotRecipeVariantKeys = [
+    "type",
+    "depth",
+    "fixedColumn",
+    "edgeFixedColumn"
+];
+const getVariantProps = (variants) => ({ ...displayTableCellSlotRecipeDefaultVariants, ...compact(variants) });
+export const displayTableCellSlotRecipe = /* @__PURE__ */ Object.assign(displayTableCellSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'displayTableCellSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: displayTableCellSlotRecipeVariantKeys,
+    variantMap: {
+        "type": [
+            "text",
+            "amount"
+        ],
+        "depth": [
+            "0",
+            "1",
+            "2",
+            "3",
+            "4",
+            "5"
+        ],
+        "fixedColumn": [
+            "true"
+        ],
+        "edgeFixedColumn": [
+            "left",
+            "right"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, displayTableCellSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/display-table-header-cell-slot-recipe.d.ts

@@ -0,0 +1,35 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface DisplayTableHeaderCellSlotRecipeVariant {
+  type: "text" | "amount"
+fixedColumn: boolean
+edgeFixedColumn: "left" | "right"
+}
+
+type DisplayTableHeaderCellSlotRecipeVariantMap = {
+  [key in keyof DisplayTableHeaderCellSlotRecipeVariant]: Array<DisplayTableHeaderCellSlotRecipeVariant[key]>
+}
+
+type DisplayTableHeaderCellSlotRecipeSlot = "root" | "content"
+
+export type DisplayTableHeaderCellSlotRecipeVariantProps = {
+  [key in keyof DisplayTableHeaderCellSlotRecipeVariant]?: ConditionalValue<DisplayTableHeaderCellSlotRecipeVariant[key]> | undefined
+}
+
+export interface DisplayTableHeaderCellSlotRecipeRecipe {
+  __slot: DisplayTableHeaderCellSlotRecipeSlot
+  __type: DisplayTableHeaderCellSlotRecipeVariantProps
+  (props?: DisplayTableHeaderCellSlotRecipeVariantProps): Pretty<Record<DisplayTableHeaderCellSlotRecipeSlot, string>>
+  raw: (props?: DisplayTableHeaderCellSlotRecipeVariantProps) => DisplayTableHeaderCellSlotRecipeVariantProps
+  variantMap: DisplayTableHeaderCellSlotRecipeVariantMap
+  variantKeys: Array<keyof DisplayTableHeaderCellSlotRecipeVariant>
+  splitVariantProps<Props extends DisplayTableHeaderCellSlotRecipeVariantProps>(props: Props): [DisplayTableHeaderCellSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisplayTableHeaderCellSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisplayTableHeaderCellSlotRecipeVariantProps) => DisplayTableHeaderCellSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DisplayTableHeaderCell component.
+ */
+export declare const displayTableHeaderCellSlotRecipe: DisplayTableHeaderCellSlotRecipeRecipe

package/dist/esm/styled-system/recipes/display-table-header-cell-slot-recipe.js

@@ -0,0 +1,48 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const displayTableHeaderCellSlotRecipeDefaultVariants = {};
+const displayTableHeaderCellSlotRecipeCompoundVariants = [];
+const displayTableHeaderCellSlotRecipeSlotNames = [
+    [
+        "root",
+        "DisplayTableHeaderCell__root"
+    ],
+    [
+        "content",
+        "DisplayTableHeaderCell__content"
+    ]
+];
+const displayTableHeaderCellSlotRecipeSlotFns = /* @__PURE__ */ displayTableHeaderCellSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, displayTableHeaderCellSlotRecipeDefaultVariants, getSlotCompoundVariant(displayTableHeaderCellSlotRecipeCompoundVariants, slotName))]);
+const displayTableHeaderCellSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(displayTableHeaderCellSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const displayTableHeaderCellSlotRecipeVariantKeys = [
+    "type",
+    "fixedColumn",
+    "edgeFixedColumn"
+];
+const getVariantProps = (variants) => ({ ...displayTableHeaderCellSlotRecipeDefaultVariants, ...compact(variants) });
+export const displayTableHeaderCellSlotRecipe = /* @__PURE__ */ Object.assign(displayTableHeaderCellSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'displayTableHeaderCellSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: displayTableHeaderCellSlotRecipeVariantKeys,
+    variantMap: {
+        "type": [
+            "text",
+            "amount"
+        ],
+        "fixedColumn": [
+            "true"
+        ],
+        "edgeFixedColumn": [
+            "left",
+            "right"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, displayTableHeaderCellSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/display-table-header-row-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 DisplayTableHeaderRowSlotRecipeVariant {
+  
+}
+
+type DisplayTableHeaderRowSlotRecipeVariantMap = {
+  [key in keyof DisplayTableHeaderRowSlotRecipeVariant]: Array<DisplayTableHeaderRowSlotRecipeVariant[key]>
+}
+
+type DisplayTableHeaderRowSlotRecipeSlot = "root"
+
+export type DisplayTableHeaderRowSlotRecipeVariantProps = {
+  [key in keyof DisplayTableHeaderRowSlotRecipeVariant]?: ConditionalValue<DisplayTableHeaderRowSlotRecipeVariant[key]> | undefined
+}
+
+export interface DisplayTableHeaderRowSlotRecipeRecipe {
+  __slot: DisplayTableHeaderRowSlotRecipeSlot
+  __type: DisplayTableHeaderRowSlotRecipeVariantProps
+  (props?: DisplayTableHeaderRowSlotRecipeVariantProps): Pretty<Record<DisplayTableHeaderRowSlotRecipeSlot, string>>
+  raw: (props?: DisplayTableHeaderRowSlotRecipeVariantProps) => DisplayTableHeaderRowSlotRecipeVariantProps
+  variantMap: DisplayTableHeaderRowSlotRecipeVariantMap
+  variantKeys: Array<keyof DisplayTableHeaderRowSlotRecipeVariant>
+  splitVariantProps<Props extends DisplayTableHeaderRowSlotRecipeVariantProps>(props: Props): [DisplayTableHeaderRowSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisplayTableHeaderRowSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisplayTableHeaderRowSlotRecipeVariantProps) => DisplayTableHeaderRowSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DisplayTableHeaderRow component.
+ */
+export declare const displayTableHeaderRowSlotRecipe: DisplayTableHeaderRowSlotRecipeRecipe

package/dist/esm/styled-system/recipes/display-table-header-row-slot-recipe.js

@@ -0,0 +1,28 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const displayTableHeaderRowSlotRecipeDefaultVariants = {};
+const displayTableHeaderRowSlotRecipeCompoundVariants = [];
+const displayTableHeaderRowSlotRecipeSlotNames = [
+    [
+        "root",
+        "DisplayTableHeaderRow__root"
+    ]
+];
+const displayTableHeaderRowSlotRecipeSlotFns = /* @__PURE__ */ displayTableHeaderRowSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, displayTableHeaderRowSlotRecipeDefaultVariants, getSlotCompoundVariant(displayTableHeaderRowSlotRecipeCompoundVariants, slotName))]);
+const displayTableHeaderRowSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(displayTableHeaderRowSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const displayTableHeaderRowSlotRecipeVariantKeys = [];
+const getVariantProps = (variants) => ({ ...displayTableHeaderRowSlotRecipeDefaultVariants, ...compact(variants) });
+export const displayTableHeaderRowSlotRecipe = /* @__PURE__ */ Object.assign(displayTableHeaderRowSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'displayTableHeaderRowSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: displayTableHeaderRowSlotRecipeVariantKeys,
+    variantMap: {},
+    splitVariantProps(props) {
+        return splitProps(props, displayTableHeaderRowSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/display-table-header-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 DisplayTableHeaderSlotRecipeVariant {
+  fixedHeader: boolean
+}
+
+type DisplayTableHeaderSlotRecipeVariantMap = {
+  [key in keyof DisplayTableHeaderSlotRecipeVariant]: Array<DisplayTableHeaderSlotRecipeVariant[key]>
+}
+
+type DisplayTableHeaderSlotRecipeSlot = "root"
+
+export type DisplayTableHeaderSlotRecipeVariantProps = {
+  [key in keyof DisplayTableHeaderSlotRecipeVariant]?: ConditionalValue<DisplayTableHeaderSlotRecipeVariant[key]> | undefined
+}
+
+export interface DisplayTableHeaderSlotRecipeRecipe {
+  __slot: DisplayTableHeaderSlotRecipeSlot
+  __type: DisplayTableHeaderSlotRecipeVariantProps
+  (props?: DisplayTableHeaderSlotRecipeVariantProps): Pretty<Record<DisplayTableHeaderSlotRecipeSlot, string>>
+  raw: (props?: DisplayTableHeaderSlotRecipeVariantProps) => DisplayTableHeaderSlotRecipeVariantProps
+  variantMap: DisplayTableHeaderSlotRecipeVariantMap
+  variantKeys: Array<keyof DisplayTableHeaderSlotRecipeVariant>
+  splitVariantProps<Props extends DisplayTableHeaderSlotRecipeVariantProps>(props: Props): [DisplayTableHeaderSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisplayTableHeaderSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisplayTableHeaderSlotRecipeVariantProps) => DisplayTableHeaderSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DisplayTableHeader component.
+ */
+export declare const displayTableHeaderSlotRecipe: DisplayTableHeaderSlotRecipeRecipe

package/dist/esm/styled-system/recipes/display-table-header-slot-recipe.js

@@ -0,0 +1,35 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const displayTableHeaderSlotRecipeDefaultVariants = {};
+const displayTableHeaderSlotRecipeCompoundVariants = [];
+const displayTableHeaderSlotRecipeSlotNames = [
+    [
+        "root",
+        "DisplayTableHeader__root"
+    ]
+];
+const displayTableHeaderSlotRecipeSlotFns = /* @__PURE__ */ displayTableHeaderSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, displayTableHeaderSlotRecipeDefaultVariants, getSlotCompoundVariant(displayTableHeaderSlotRecipeCompoundVariants, slotName))]);
+const displayTableHeaderSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(displayTableHeaderSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const displayTableHeaderSlotRecipeVariantKeys = [
+    "fixedHeader"
+];
+const getVariantProps = (variants) => ({ ...displayTableHeaderSlotRecipeDefaultVariants, ...compact(variants) });
+export const displayTableHeaderSlotRecipe = /* @__PURE__ */ Object.assign(displayTableHeaderSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'displayTableHeaderSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: displayTableHeaderSlotRecipeVariantKeys,
+    variantMap: {
+        "fixedHeader": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, displayTableHeaderSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/display-table-row-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 DisplayTableRowSlotRecipeVariant {
+  isTotal: boolean
+}
+
+type DisplayTableRowSlotRecipeVariantMap = {
+  [key in keyof DisplayTableRowSlotRecipeVariant]: Array<DisplayTableRowSlotRecipeVariant[key]>
+}
+
+type DisplayTableRowSlotRecipeSlot = "root"
+
+export type DisplayTableRowSlotRecipeVariantProps = {
+  [key in keyof DisplayTableRowSlotRecipeVariant]?: ConditionalValue<DisplayTableRowSlotRecipeVariant[key]> | undefined
+}
+
+export interface DisplayTableRowSlotRecipeRecipe {
+  __slot: DisplayTableRowSlotRecipeSlot
+  __type: DisplayTableRowSlotRecipeVariantProps
+  (props?: DisplayTableRowSlotRecipeVariantProps): Pretty<Record<DisplayTableRowSlotRecipeSlot, string>>
+  raw: (props?: DisplayTableRowSlotRecipeVariantProps) => DisplayTableRowSlotRecipeVariantProps
+  variantMap: DisplayTableRowSlotRecipeVariantMap
+  variantKeys: Array<keyof DisplayTableRowSlotRecipeVariant>
+  splitVariantProps<Props extends DisplayTableRowSlotRecipeVariantProps>(props: Props): [DisplayTableRowSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisplayTableRowSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisplayTableRowSlotRecipeVariantProps) => DisplayTableRowSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DisplayTableRow component.
+ */
+export declare const displayTableRowSlotRecipe: DisplayTableRowSlotRecipeRecipe

package/dist/esm/styled-system/recipes/display-table-row-slot-recipe.js

@@ -0,0 +1,35 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const displayTableRowSlotRecipeDefaultVariants = {};
+const displayTableRowSlotRecipeCompoundVariants = [];
+const displayTableRowSlotRecipeSlotNames = [
+    [
+        "root",
+        "DisplayTableRow__root"
+    ]
+];
+const displayTableRowSlotRecipeSlotFns = /* @__PURE__ */ displayTableRowSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, displayTableRowSlotRecipeDefaultVariants, getSlotCompoundVariant(displayTableRowSlotRecipeCompoundVariants, slotName))]);
+const displayTableRowSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(displayTableRowSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const displayTableRowSlotRecipeVariantKeys = [
+    "isTotal"
+];
+const getVariantProps = (variants) => ({ ...displayTableRowSlotRecipeDefaultVariants, ...compact(variants) });
+export const displayTableRowSlotRecipe = /* @__PURE__ */ Object.assign(displayTableRowSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'displayTableRowSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: displayTableRowSlotRecipeVariantKeys,
+    variantMap: {
+        "isTotal": [
+            "true",
+            "false"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, displayTableRowSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

package/dist/esm/styled-system/recipes/display-table-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 DisplayTableSlotRecipeVariant {
+  fixedHeader: boolean
+}
+
+type DisplayTableSlotRecipeVariantMap = {
+  [key in keyof DisplayTableSlotRecipeVariant]: Array<DisplayTableSlotRecipeVariant[key]>
+}
+
+type DisplayTableSlotRecipeSlot = "wrapper" | "header" | "title" | "lead" | "body" | "table"
+
+export type DisplayTableSlotRecipeVariantProps = {
+  [key in keyof DisplayTableSlotRecipeVariant]?: ConditionalValue<DisplayTableSlotRecipeVariant[key]> | undefined
+}
+
+export interface DisplayTableSlotRecipeRecipe {
+  __slot: DisplayTableSlotRecipeSlot
+  __type: DisplayTableSlotRecipeVariantProps
+  (props?: DisplayTableSlotRecipeVariantProps): Pretty<Record<DisplayTableSlotRecipeSlot, string>>
+  raw: (props?: DisplayTableSlotRecipeVariantProps) => DisplayTableSlotRecipeVariantProps
+  variantMap: DisplayTableSlotRecipeVariantMap
+  variantKeys: Array<keyof DisplayTableSlotRecipeVariant>
+  splitVariantProps<Props extends DisplayTableSlotRecipeVariantProps>(props: Props): [DisplayTableSlotRecipeVariantProps, Pretty<DistributiveOmit<Props, keyof DisplayTableSlotRecipeVariantProps>>]
+  getVariantProps: (props?: DisplayTableSlotRecipeVariantProps) => DisplayTableSlotRecipeVariantProps
+}
+
+/**
+ * Slot class created for the MFUI DisplayTable component.
+ */
+export declare const displayTableSlotRecipe: DisplayTableSlotRecipeRecipe

package/dist/esm/styled-system/recipes/display-table-slot-recipe.js

@@ -0,0 +1,54 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+const displayTableSlotRecipeDefaultVariants = {};
+const displayTableSlotRecipeCompoundVariants = [];
+const displayTableSlotRecipeSlotNames = [
+    [
+        "wrapper",
+        "DisplayTable__wrapper"
+    ],
+    [
+        "header",
+        "DisplayTable__header"
+    ],
+    [
+        "title",
+        "DisplayTable__title"
+    ],
+    [
+        "lead",
+        "DisplayTable__lead"
+    ],
+    [
+        "body",
+        "DisplayTable__body"
+    ],
+    [
+        "table",
+        "DisplayTable__table"
+    ]
+];
+const displayTableSlotRecipeSlotFns = /* @__PURE__ */ displayTableSlotRecipeSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, displayTableSlotRecipeDefaultVariants, getSlotCompoundVariant(displayTableSlotRecipeCompoundVariants, slotName))]);
+const displayTableSlotRecipeFn = memo((props = {}) => {
+    return Object.fromEntries(displayTableSlotRecipeSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]));
+});
+const displayTableSlotRecipeVariantKeys = [
+    "fixedHeader"
+];
+const getVariantProps = (variants) => ({ ...displayTableSlotRecipeDefaultVariants, ...compact(variants) });
+export const displayTableSlotRecipe = /* @__PURE__ */ Object.assign(displayTableSlotRecipeFn, {
+    __recipe__: false,
+    __name__: 'displayTableSlotRecipe',
+    raw: (props) => props,
+    classNameMap: {},
+    variantKeys: displayTableSlotRecipeVariantKeys,
+    variantMap: {
+        "fixedHeader": [
+            "true"
+        ]
+    },
+    splitVariantProps(props) {
+        return splitProps(props, displayTableSlotRecipeVariantKeys);
+    },
+    getVariantProps
+});

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