@svadmin/surface 0.9.0 → 0.10.0

package/dist/styled-system/recipes/product-settings-row.js

@@ -1,58 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const productSettingsRowDefaultVariants = {
-  "separated": false
-}
-const productSettingsRowCompoundVariants = []
-
-const productSettingsRowSlotNames = [
-  [
-    "root",
-    "product-settings-row__root"
-  ],
-  [
-    "heading",
-    "product-settings-row__heading"
-  ],
-  [
-    "label",
-    "product-settings-row__label"
-  ],
-  [
-    "description",
-    "product-settings-row__description"
-  ],
-  [
-    "control",
-    "product-settings-row__control"
-  ]
-]
-const productSettingsRowSlotFns = /* @__PURE__ */ productSettingsRowSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productSettingsRowDefaultVariants, getSlotCompoundVariant(productSettingsRowCompoundVariants, slotName))])
-
-const productSettingsRowFn = memo((props = {}) => {
-  return Object.fromEntries(productSettingsRowSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const productSettingsRowVariantKeys = [
-  "separated"
-]
-const getVariantProps = (variants) => ({ ...productSettingsRowDefaultVariants, ...compact(variants) })
-
-export const productSettingsRow = /* @__PURE__ */ Object.assign(productSettingsRowFn, {
-  __recipe__: false,
-  __name__: 'productSettingsRow',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: productSettingsRowVariantKeys,
-  variantMap: {
-  "separated": [
-    "true",
-    "false"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, productSettingsRowVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/product-settings.d.ts

@@ -1,31 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface ProductSettingsVariant {
-  
-}
-
-type ProductSettingsVariantMap = {
-  [key in keyof ProductSettingsVariant]: Array<ProductSettingsVariant[key]>
-}
-
-type ProductSettingsSlot = "root" | "header" | "heading" | "title" | "description" | "actions" | "body"
-
-export type ProductSettingsVariantProps = {
-  [key in keyof ProductSettingsVariant]?: ConditionalValue<ProductSettingsVariant[key]> | undefined
-}
-
-export interface ProductSettingsRecipe {
-  __slot: ProductSettingsSlot
-  __type: ProductSettingsVariantProps
-  (props?: ProductSettingsVariantProps): Pretty<Record<ProductSettingsSlot, string>>
-  raw: (props?: ProductSettingsVariantProps) => ProductSettingsVariantProps
-  variantMap: ProductSettingsVariantMap
-  variantKeys: Array<keyof ProductSettingsVariant>
-  splitVariantProps<Props extends ProductSettingsVariantProps>(props: Props): [ProductSettingsVariantProps, Pretty<DistributiveOmit<Props, keyof ProductSettingsVariantProps>>]
-  getVariantProps: (props?: ProductSettingsVariantProps) => ProductSettingsVariantProps
-}
-
-
-export declare const productSettings: ProductSettingsRecipe

package/dist/styled-system/recipes/product-settings.js

@@ -1,57 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const productSettingsDefaultVariants = {}
-const productSettingsCompoundVariants = []
-
-const productSettingsSlotNames = [
-  [
-    "root",
-    "product-settings__root"
-  ],
-  [
-    "header",
-    "product-settings__header"
-  ],
-  [
-    "heading",
-    "product-settings__heading"
-  ],
-  [
-    "title",
-    "product-settings__title"
-  ],
-  [
-    "description",
-    "product-settings__description"
-  ],
-  [
-    "actions",
-    "product-settings__actions"
-  ],
-  [
-    "body",
-    "product-settings__body"
-  ]
-]
-const productSettingsSlotFns = /* @__PURE__ */ productSettingsSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productSettingsDefaultVariants, getSlotCompoundVariant(productSettingsCompoundVariants, slotName))])
-
-const productSettingsFn = memo((props = {}) => {
-  return Object.fromEntries(productSettingsSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const productSettingsVariantKeys = []
-const getVariantProps = (variants) => ({ ...productSettingsDefaultVariants, ...compact(variants) })
-
-export const productSettings = /* @__PURE__ */ Object.assign(productSettingsFn, {
-  __recipe__: false,
-  __name__: 'productSettings',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: productSettingsVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, productSettingsVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/product-status.d.ts

@@ -1,34 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface ProductStatusVariant {
-  /**
- * @default "neutral"
- */
-status: "success" | "warning" | "danger" | "info" | "neutral"
-}
-
-type ProductStatusVariantMap = {
-  [key in keyof ProductStatusVariant]: Array<ProductStatusVariant[key]>
-}
-
-type ProductStatusSlot = "root"
-
-export type ProductStatusVariantProps = {
-  [key in keyof ProductStatusVariant]?: ConditionalValue<ProductStatusVariant[key]> | undefined
-}
-
-export interface ProductStatusRecipe {
-  __slot: ProductStatusSlot
-  __type: ProductStatusVariantProps
-  (props?: ProductStatusVariantProps): Pretty<Record<ProductStatusSlot, string>>
-  raw: (props?: ProductStatusVariantProps) => ProductStatusVariantProps
-  variantMap: ProductStatusVariantMap
-  variantKeys: Array<keyof ProductStatusVariant>
-  splitVariantProps<Props extends ProductStatusVariantProps>(props: Props): [ProductStatusVariantProps, Pretty<DistributiveOmit<Props, keyof ProductStatusVariantProps>>]
-  getVariantProps: (props?: ProductStatusVariantProps) => ProductStatusVariantProps
-}
-
-
-export declare const productStatus: ProductStatusRecipe

package/dist/styled-system/recipes/product-status.js

@@ -1,45 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const productStatusDefaultVariants = {
-  "status": "neutral"
-}
-const productStatusCompoundVariants = []
-
-const productStatusSlotNames = [
-  [
-    "root",
-    "product-status__root"
-  ]
-]
-const productStatusSlotFns = /* @__PURE__ */ productStatusSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productStatusDefaultVariants, getSlotCompoundVariant(productStatusCompoundVariants, slotName))])
-
-const productStatusFn = memo((props = {}) => {
-  return Object.fromEntries(productStatusSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const productStatusVariantKeys = [
-  "status"
-]
-const getVariantProps = (variants) => ({ ...productStatusDefaultVariants, ...compact(variants) })
-
-export const productStatus = /* @__PURE__ */ Object.assign(productStatusFn, {
-  __recipe__: false,
-  __name__: 'productStatus',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: productStatusVariantKeys,
-  variantMap: {
-  "status": [
-    "success",
-    "warning",
-    "danger",
-    "info",
-    "neutral"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, productStatusVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/product-toolbar.d.ts

@@ -1,31 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface ProductToolbarVariant {
-  
-}
-
-type ProductToolbarVariantMap = {
-  [key in keyof ProductToolbarVariant]: Array<ProductToolbarVariant[key]>
-}
-
-type ProductToolbarSlot = "root" | "leading" | "trailing"
-
-export type ProductToolbarVariantProps = {
-  [key in keyof ProductToolbarVariant]?: ConditionalValue<ProductToolbarVariant[key]> | undefined
-}
-
-export interface ProductToolbarRecipe {
-  __slot: ProductToolbarSlot
-  __type: ProductToolbarVariantProps
-  (props?: ProductToolbarVariantProps): Pretty<Record<ProductToolbarSlot, string>>
-  raw: (props?: ProductToolbarVariantProps) => ProductToolbarVariantProps
-  variantMap: ProductToolbarVariantMap
-  variantKeys: Array<keyof ProductToolbarVariant>
-  splitVariantProps<Props extends ProductToolbarVariantProps>(props: Props): [ProductToolbarVariantProps, Pretty<DistributiveOmit<Props, keyof ProductToolbarVariantProps>>]
-  getVariantProps: (props?: ProductToolbarVariantProps) => ProductToolbarVariantProps
-}
-
-
-export declare const productToolbar: ProductToolbarRecipe

package/dist/styled-system/recipes/product-toolbar.js

@@ -1,41 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const productToolbarDefaultVariants = {}
-const productToolbarCompoundVariants = []
-
-const productToolbarSlotNames = [
-  [
-    "root",
-    "product-toolbar__root"
-  ],
-  [
-    "leading",
-    "product-toolbar__leading"
-  ],
-  [
-    "trailing",
-    "product-toolbar__trailing"
-  ]
-]
-const productToolbarSlotFns = /* @__PURE__ */ productToolbarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productToolbarDefaultVariants, getSlotCompoundVariant(productToolbarCompoundVariants, slotName))])
-
-const productToolbarFn = memo((props = {}) => {
-  return Object.fromEntries(productToolbarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const productToolbarVariantKeys = []
-const getVariantProps = (variants) => ({ ...productToolbarDefaultVariants, ...compact(variants) })
-
-export const productToolbar = /* @__PURE__ */ Object.assign(productToolbarFn, {
-  __recipe__: false,
-  __name__: 'productToolbar',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: productToolbarVariantKeys,
-  variantMap: {},
-  splitVariantProps(props) {
-    return splitProps(props, productToolbarVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/product-workspace.d.ts

@@ -1,34 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface ProductWorkspaceVariant {
-  /**
- * @default false
- */
-hasSecondary: boolean
-}
-
-type ProductWorkspaceVariantMap = {
-  [key in keyof ProductWorkspaceVariant]: Array<ProductWorkspaceVariant[key]>
-}
-
-type ProductWorkspaceSlot = "root" | "summary" | "columns" | "primary" | "secondary"
-
-export type ProductWorkspaceVariantProps = {
-  [key in keyof ProductWorkspaceVariant]?: ConditionalValue<ProductWorkspaceVariant[key]> | undefined
-}
-
-export interface ProductWorkspaceRecipe {
-  __slot: ProductWorkspaceSlot
-  __type: ProductWorkspaceVariantProps
-  (props?: ProductWorkspaceVariantProps): Pretty<Record<ProductWorkspaceSlot, string>>
-  raw: (props?: ProductWorkspaceVariantProps) => ProductWorkspaceVariantProps
-  variantMap: ProductWorkspaceVariantMap
-  variantKeys: Array<keyof ProductWorkspaceVariant>
-  splitVariantProps<Props extends ProductWorkspaceVariantProps>(props: Props): [ProductWorkspaceVariantProps, Pretty<DistributiveOmit<Props, keyof ProductWorkspaceVariantProps>>]
-  getVariantProps: (props?: ProductWorkspaceVariantProps) => ProductWorkspaceVariantProps
-}
-
-
-export declare const productWorkspace: ProductWorkspaceRecipe

package/dist/styled-system/recipes/product-workspace.js

@@ -1,58 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const productWorkspaceDefaultVariants = {
-  "hasSecondary": false
-}
-const productWorkspaceCompoundVariants = []
-
-const productWorkspaceSlotNames = [
-  [
-    "root",
-    "product-workspace__root"
-  ],
-  [
-    "summary",
-    "product-workspace__summary"
-  ],
-  [
-    "columns",
-    "product-workspace__columns"
-  ],
-  [
-    "primary",
-    "product-workspace__primary"
-  ],
-  [
-    "secondary",
-    "product-workspace__secondary"
-  ]
-]
-const productWorkspaceSlotFns = /* @__PURE__ */ productWorkspaceSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, productWorkspaceDefaultVariants, getSlotCompoundVariant(productWorkspaceCompoundVariants, slotName))])
-
-const productWorkspaceFn = memo((props = {}) => {
-  return Object.fromEntries(productWorkspaceSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const productWorkspaceVariantKeys = [
-  "hasSecondary"
-]
-const getVariantProps = (variants) => ({ ...productWorkspaceDefaultVariants, ...compact(variants) })
-
-export const productWorkspace = /* @__PURE__ */ Object.assign(productWorkspaceFn, {
-  __recipe__: false,
-  __name__: 'productWorkspace',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: productWorkspaceVariantKeys,
-  variantMap: {
-  "hasSecondary": [
-    "true",
-    "false"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, productWorkspaceVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/surface-metric.d.ts

@@ -1,38 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface SurfaceMetricVariant {
-  /**
- * @default "neutral"
- */
-tone: "neutral" | "success" | "warning" | "danger" | "info"
-/**
- * @default "comfortable"
- */
-density: "comfortable" | "compact"
-}
-
-type SurfaceMetricVariantMap = {
-  [key in keyof SurfaceMetricVariant]: Array<SurfaceMetricVariant[key]>
-}
-
-type SurfaceMetricSlot = "root" | "card" | "description" | "state"
-
-export type SurfaceMetricVariantProps = {
-  [key in keyof SurfaceMetricVariant]?: ConditionalValue<SurfaceMetricVariant[key]> | undefined
-}
-
-export interface SurfaceMetricRecipe {
-  __slot: SurfaceMetricSlot
-  __type: SurfaceMetricVariantProps
-  (props?: SurfaceMetricVariantProps): Pretty<Record<SurfaceMetricSlot, string>>
-  raw: (props?: SurfaceMetricVariantProps) => SurfaceMetricVariantProps
-  variantMap: SurfaceMetricVariantMap
-  variantKeys: Array<keyof SurfaceMetricVariant>
-  splitVariantProps<Props extends SurfaceMetricVariantProps>(props: Props): [SurfaceMetricVariantProps, Pretty<DistributiveOmit<Props, keyof SurfaceMetricVariantProps>>]
-  getVariantProps: (props?: SurfaceMetricVariantProps) => SurfaceMetricVariantProps
-}
-
-
-export declare const surfaceMetric: SurfaceMetricRecipe

package/dist/styled-system/recipes/surface-metric.js

@@ -1,63 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const surfaceMetricDefaultVariants = {
-  "tone": "neutral",
-  "density": "comfortable"
-}
-const surfaceMetricCompoundVariants = []
-
-const surfaceMetricSlotNames = [
-  [
-    "root",
-    "surface-metric__root"
-  ],
-  [
-    "card",
-    "surface-metric__card"
-  ],
-  [
-    "description",
-    "surface-metric__description"
-  ],
-  [
-    "state",
-    "surface-metric__state"
-  ]
-]
-const surfaceMetricSlotFns = /* @__PURE__ */ surfaceMetricSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, surfaceMetricDefaultVariants, getSlotCompoundVariant(surfaceMetricCompoundVariants, slotName))])
-
-const surfaceMetricFn = memo((props = {}) => {
-  return Object.fromEntries(surfaceMetricSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const surfaceMetricVariantKeys = [
-  "tone",
-  "density"
-]
-const getVariantProps = (variants) => ({ ...surfaceMetricDefaultVariants, ...compact(variants) })
-
-export const surfaceMetric = /* @__PURE__ */ Object.assign(surfaceMetricFn, {
-  __recipe__: false,
-  __name__: 'surfaceMetric',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: surfaceMetricVariantKeys,
-  variantMap: {
-  "tone": [
-    "neutral",
-    "success",
-    "warning",
-    "danger",
-    "info"
-  ],
-  "density": [
-    "comfortable",
-    "compact"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, surfaceMetricVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/surface-table.d.ts

@@ -1,34 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface SurfaceTableVariant {
-  /**
- * @default "comfortable"
- */
-density: "comfortable" | "compact"
-}
-
-type SurfaceTableVariantMap = {
-  [key in keyof SurfaceTableVariant]: Array<SurfaceTableVariant[key]>
-}
-
-type SurfaceTableSlot = "root" | "header" | "content" | "head" | "cell" | "state"
-
-export type SurfaceTableVariantProps = {
-  [key in keyof SurfaceTableVariant]?: ConditionalValue<SurfaceTableVariant[key]> | undefined
-}
-
-export interface SurfaceTableRecipe {
-  __slot: SurfaceTableSlot
-  __type: SurfaceTableVariantProps
-  (props?: SurfaceTableVariantProps): Pretty<Record<SurfaceTableSlot, string>>
-  raw: (props?: SurfaceTableVariantProps) => SurfaceTableVariantProps
-  variantMap: SurfaceTableVariantMap
-  variantKeys: Array<keyof SurfaceTableVariant>
-  splitVariantProps<Props extends SurfaceTableVariantProps>(props: Props): [SurfaceTableVariantProps, Pretty<DistributiveOmit<Props, keyof SurfaceTableVariantProps>>]
-  getVariantProps: (props?: SurfaceTableVariantProps) => SurfaceTableVariantProps
-}
-
-
-export declare const surfaceTable: SurfaceTableRecipe

package/dist/styled-system/recipes/surface-table.js

@@ -1,62 +0,0 @@
-import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
-import { createRecipe } from './create-recipe.js';
-
-const surfaceTableDefaultVariants = {
-  "density": "comfortable"
-}
-const surfaceTableCompoundVariants = []
-
-const surfaceTableSlotNames = [
-  [
-    "root",
-    "surface-table__root"
-  ],
-  [
-    "header",
-    "surface-table__header"
-  ],
-  [
-    "content",
-    "surface-table__content"
-  ],
-  [
-    "head",
-    "surface-table__head"
-  ],
-  [
-    "cell",
-    "surface-table__cell"
-  ],
-  [
-    "state",
-    "surface-table__state"
-  ]
-]
-const surfaceTableSlotFns = /* @__PURE__ */ surfaceTableSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, surfaceTableDefaultVariants, getSlotCompoundVariant(surfaceTableCompoundVariants, slotName))])
-
-const surfaceTableFn = memo((props = {}) => {
-  return Object.fromEntries(surfaceTableSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
-})
-
-const surfaceTableVariantKeys = [
-  "density"
-]
-const getVariantProps = (variants) => ({ ...surfaceTableDefaultVariants, ...compact(variants) })
-
-export const surfaceTable = /* @__PURE__ */ Object.assign(surfaceTableFn, {
-  __recipe__: false,
-  __name__: 'surfaceTable',
-  raw: (props) => props,
-  classNameMap: {},
-  variantKeys: surfaceTableVariantKeys,
-  variantMap: {
-  "density": [
-    "comfortable",
-    "compact"
-  ]
-},
-  splitVariantProps(props) {
-    return splitProps(props, surfaceTableVariantKeys)
-  },
-  getVariantProps
-})

package/dist/styled-system/recipes/ui-badge.d.ts

@@ -1,31 +0,0 @@
-/* eslint-disable */
-import type { ConditionalValue } from '../types/index';
-import type { DistributiveOmit, Pretty } from '../types/system-types';
-
-interface UiBadgeVariant {
-  variant: "default" | "secondary" | "destructive" | "subtle" | "subtle-success" | "subtle-warning" | "subtle-destructive" | "subtle-pill" | "outline" | "ghost" | "link"
-}
-
-type UiBadgeVariantMap = {
-  [key in keyof UiBadgeVariant]: Array<UiBadgeVariant[key]>
-}
-
-
-
-export type UiBadgeVariantProps = {
-  [key in keyof UiBadgeVariant]?: ConditionalValue<UiBadgeVariant[key]> | undefined
-}
-
-export interface UiBadgeRecipe {
-  
-  __type: UiBadgeVariantProps
-  (props?: UiBadgeVariantProps): string
-  raw: (props?: UiBadgeVariantProps) => UiBadgeVariantProps
-  variantMap: UiBadgeVariantMap
-  variantKeys: Array<keyof UiBadgeVariant>
-  splitVariantProps<Props extends UiBadgeVariantProps>(props: Props): [UiBadgeVariantProps, Pretty<DistributiveOmit<Props, keyof UiBadgeVariantProps>>]
-  getVariantProps: (props?: UiBadgeVariantProps) => UiBadgeVariantProps
-}
-
-
-export declare const uiBadge: UiBadgeRecipe

package/dist/styled-system/recipes/ui-badge.js

@@ -1,38 +0,0 @@
-import { memo, splitProps } from '../helpers.js';
-import { createRecipe, mergeRecipes } from './create-recipe.js';
-
-const uiBadgeFn = /* @__PURE__ */ createRecipe('ui-badge', {}, [])
-
-const uiBadgeVariantMap = {
-  "variant": [
-    "default",
-    "secondary",
-    "destructive",
-    "subtle",
-    "subtle-success",
-    "subtle-warning",
-    "subtle-destructive",
-    "subtle-pill",
-    "outline",
-    "ghost",
-    "link"
-  ]
-}
-
-const uiBadgeVariantKeys = Object.keys(uiBadgeVariantMap)
-
-export const uiBadge = /* @__PURE__ */ Object.assign(memo(uiBadgeFn.recipeFn), {
-  __recipe__: true,
-  __name__: 'uiBadge',
-  __getCompoundVariantCss__: uiBadgeFn.__getCompoundVariantCss__,
-  raw: (props) => props,
-  variantKeys: uiBadgeVariantKeys,
-  variantMap: uiBadgeVariantMap,
-  merge(recipe) {
-    return mergeRecipes(this, recipe)
-  },
-  splitVariantProps(props) {
-    return splitProps(props, uiBadgeVariantKeys)
-  },
-  getVariantProps: uiBadgeFn.getVariantProps,
-})