aeon-ui-engine 1.0.2 → 1.1.0

package/packages/panda/styled-system/recipes/aeon-bar.d.ts

@@ -0,0 +1,40 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonBarVariant {
+  /**
+ * @default "sm"
+ */
+size: "xs" | "sm" | "md" | "lg"
+sticky: boolean
+placement: "top" | "bottom" | "inline"
+/**
+ * @default "shrink"
+ */
+collapse: "shrink" | "wrap" | "collapse-center"
+}
+
+type AeonBarVariantMap = {
+  [key in keyof AeonBarVariant]: Array<AeonBarVariant[key]>
+}
+
+type AeonBarSlot = "root" | "leading" | "center" | "trailing" | "seam"
+
+export type AeonBarVariantProps = {
+  [key in keyof AeonBarVariant]?: ConditionalValue<AeonBarVariant[key]> | undefined
+}
+
+export interface AeonBarRecipe {
+  __slot: AeonBarSlot
+  __type: AeonBarVariantProps
+  (props?: AeonBarVariantProps): Pretty<Record<AeonBarSlot, string>>
+  raw: (props?: AeonBarVariantProps) => AeonBarVariantProps
+  variantMap: AeonBarVariantMap
+  variantKeys: Array<keyof AeonBarVariant>
+  splitVariantProps<Props extends AeonBarVariantProps>(props: Props): [AeonBarVariantProps, Pretty<DistributiveOmit<Props, keyof AeonBarVariantProps>>]
+  getVariantProps: (props?: AeonBarVariantProps) => AeonBarVariantProps
+}
+
+
+export declare const aeonBar: AeonBarRecipe

package/packages/panda/styled-system/recipes/aeon-bar.mjs

@@ -0,0 +1,77 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonBarDefaultVariants = {
+  "size": "sm",
+  "collapse": "shrink"
+}
+const aeonBarCompoundVariants = []
+
+const aeonBarSlotNames = [
+  [
+    "root",
+    "aeonBar__root"
+  ],
+  [
+    "leading",
+    "aeonBar__leading"
+  ],
+  [
+    "center",
+    "aeonBar__center"
+  ],
+  [
+    "trailing",
+    "aeonBar__trailing"
+  ],
+  [
+    "seam",
+    "aeonBar__seam"
+  ]
+]
+const aeonBarSlotFns = /* @__PURE__ */ aeonBarSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonBarDefaultVariants, getSlotCompoundVariant(aeonBarCompoundVariants, slotName))])
+
+const aeonBarFn = memo((props = {}) => {
+  return Object.fromEntries(aeonBarSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonBarVariantKeys = [
+  "size",
+  "sticky",
+  "placement",
+  "collapse"
+]
+const getVariantProps = (variants) => ({ ...aeonBarDefaultVariants, ...compact(variants) })
+
+export const aeonBar = /* @__PURE__ */ Object.assign(aeonBarFn, {
+  __recipe__: false,
+  __name__: 'aeonBar',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: aeonBarVariantKeys,
+  variantMap: {
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ],
+  "sticky": [
+    "true"
+  ],
+  "placement": [
+    "top",
+    "bottom",
+    "inline"
+  ],
+  "collapse": [
+    "shrink",
+    "wrap",
+    "collapse-center"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, aeonBarVariantKeys)
+  },
+  getVariantProps
+})

package/packages/panda/styled-system/recipes/aeon-button-group.d.ts

@@ -17,11 +17,14 @@ type AeonButtonGroupVariantMap = {
   [key in keyof AeonButtonGroupVariant]: Array<AeonButtonGroupVariant[key]>
 }
 
+
+
 export type AeonButtonGroupVariantProps = {
   [key in keyof AeonButtonGroupVariant]?: ConditionalValue<AeonButtonGroupVariant[key]> | undefined
 }
 
 export interface AeonButtonGroupRecipe {
+  
   __type: AeonButtonGroupVariantProps
   (props?: AeonButtonGroupVariantProps): string
   raw: (props?: AeonButtonGroupVariantProps) => AeonButtonGroupVariantProps
@@ -33,7 +36,5 @@ export interface AeonButtonGroupRecipe {
 
 /**
  * Horizontal or vertical stack of buttons with consistent spacing
-
-
  */
 export declare const aeonButtonGroup: AeonButtonGroupRecipe

package/packages/panda/styled-system/recipes/aeon-button.d.ts

@@ -17,11 +17,14 @@ type AeonButtonVariantMap = {
   [key in keyof AeonButtonVariant]: Array<AeonButtonVariant[key]>
 }
 
+
+
 export type AeonButtonVariantProps = {
   [key in keyof AeonButtonVariant]?: ConditionalValue<AeonButtonVariant[key]> | undefined
 }
 
 export interface AeonButtonRecipe {
+  
   __type: AeonButtonVariantProps
   (props?: AeonButtonVariantProps): string
   raw: (props?: AeonButtonVariantProps) => AeonButtonVariantProps
@@ -33,7 +36,5 @@ export interface AeonButtonRecipe {
 
 /**
  * Aeon button styles
-
-
  */
 export declare const aeonButton: AeonButtonRecipe

package/packages/panda/styled-system/recipes/aeon-checkbox.d.ts

@@ -10,13 +10,16 @@ type AeonCheckboxVariantMap = {
   [key in keyof AeonCheckboxVariant]: Array<AeonCheckboxVariant[key]>
 }
 
+type AeonCheckboxSlot = "root" | "control" | "indicator" | "label" | "hiddenInput"
+
 export type AeonCheckboxVariantProps = {
   [key in keyof AeonCheckboxVariant]?: ConditionalValue<AeonCheckboxVariant[key]> | undefined
 }
 
 export interface AeonCheckboxRecipe {
+  __slot: AeonCheckboxSlot
   __type: AeonCheckboxVariantProps
-  (props?: AeonCheckboxVariantProps): Pretty<Record<"root" | "control" | "indicator" | "label" | "hiddenInput", string>>
+  (props?: AeonCheckboxVariantProps): Pretty<Record<AeonCheckboxSlot, string>>
   raw: (props?: AeonCheckboxVariantProps) => AeonCheckboxVariantProps
   variantMap: AeonCheckboxVariantMap
   variantKeys: Array<keyof AeonCheckboxVariant>

package/packages/panda/styled-system/recipes/aeon-checkbox.mjs

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

package/packages/panda/styled-system/recipes/aeon-combobox.d.ts

@@ -10,13 +10,16 @@ type AeonComboboxVariantMap = {
   [key in keyof AeonComboboxVariant]: Array<AeonComboboxVariant[key]>
 }
 
+type AeonComboboxSlot = "root" | "input" | "icon" | "content" | "item" | "empty"
+
 export type AeonComboboxVariantProps = {
   [key in keyof AeonComboboxVariant]?: ConditionalValue<AeonComboboxVariant[key]> | undefined
 }
 
 export interface AeonComboboxRecipe {
+  __slot: AeonComboboxSlot
   __type: AeonComboboxVariantProps
-  (props?: AeonComboboxVariantProps): Pretty<Record<"root" | "input" | "icon" | "content" | "item" | "empty", string>>
+  (props?: AeonComboboxVariantProps): Pretty<Record<AeonComboboxSlot, string>>
   raw: (props?: AeonComboboxVariantProps) => AeonComboboxVariantProps
   variantMap: AeonComboboxVariantMap
   variantKeys: Array<keyof AeonComboboxVariant>
@@ -26,7 +29,5 @@ export interface AeonComboboxRecipe {
 
 /**
  * Filterable combobox — input + listbox (extends select patterns)
-
-
  */
 export declare const aeonCombobox: AeonComboboxRecipe

package/packages/panda/styled-system/recipes/aeon-combobox.mjs

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

package/packages/panda/styled-system/recipes/aeon-composer.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonComposerVariant {
+  
+}
+
+type AeonComposerVariantMap = {
+  [key in keyof AeonComposerVariant]: Array<AeonComposerVariant[key]>
+}
+
+type AeonComposerSlot = "root" | "input" | "actions" | "send"
+
+export type AeonComposerVariantProps = {
+  [key in keyof AeonComposerVariant]?: ConditionalValue<AeonComposerVariant[key]> | undefined
+}
+
+export interface AeonComposerRecipe {
+  __slot: AeonComposerSlot
+  __type: AeonComposerVariantProps
+  (props?: AeonComposerVariantProps): Pretty<Record<AeonComposerSlot, string>>
+  raw: (props?: AeonComposerVariantProps) => AeonComposerVariantProps
+  variantMap: AeonComposerVariantMap
+  variantKeys: Array<keyof AeonComposerVariant>
+  splitVariantProps<Props extends AeonComposerVariantProps>(props: Props): [AeonComposerVariantProps, Pretty<DistributiveOmit<Props, keyof AeonComposerVariantProps>>]
+  getVariantProps: (props?: AeonComposerVariantProps) => AeonComposerVariantProps
+}
+
+
+export declare const aeonComposer: AeonComposerRecipe

package/packages/panda/styled-system/recipes/aeon-composer.mjs

@@ -0,0 +1,45 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonComposerDefaultVariants = {}
+const aeonComposerCompoundVariants = []
+
+const aeonComposerSlotNames = [
+  [
+    "root",
+    "aeonComposer__root"
+  ],
+  [
+    "input",
+    "aeonComposer__input"
+  ],
+  [
+    "actions",
+    "aeonComposer__actions"
+  ],
+  [
+    "send",
+    "aeonComposer__send"
+  ]
+]
+const aeonComposerSlotFns = /* @__PURE__ */ aeonComposerSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonComposerDefaultVariants, getSlotCompoundVariant(aeonComposerCompoundVariants, slotName))])
+
+const aeonComposerFn = memo((props = {}) => {
+  return Object.fromEntries(aeonComposerSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonComposerVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonComposerDefaultVariants, ...compact(variants) })
+
+export const aeonComposer = /* @__PURE__ */ Object.assign(aeonComposerFn, {
+  __recipe__: false,
+  __name__: 'aeonComposer',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: aeonComposerVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonComposerVariantKeys)
+  },
+  getVariantProps
+})

package/packages/panda/styled-system/recipes/aeon-content.d.ts

@@ -0,0 +1,34 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonContentVariant {
+  /**
+ * @default "start"
+ */
+align: "start" | "center"
+}
+
+type AeonContentVariantMap = {
+  [key in keyof AeonContentVariant]: Array<AeonContentVariant[key]>
+}
+
+type AeonContentSlot = "root" | "toolbar" | "body" | "pending" | "empty" | "error" | "success" | "sentinel"
+
+export type AeonContentVariantProps = {
+  [key in keyof AeonContentVariant]?: ConditionalValue<AeonContentVariant[key]> | undefined
+}
+
+export interface AeonContentRecipe {
+  __slot: AeonContentSlot
+  __type: AeonContentVariantProps
+  (props?: AeonContentVariantProps): Pretty<Record<AeonContentSlot, string>>
+  raw: (props?: AeonContentVariantProps) => AeonContentVariantProps
+  variantMap: AeonContentVariantMap
+  variantKeys: Array<keyof AeonContentVariant>
+  splitVariantProps<Props extends AeonContentVariantProps>(props: Props): [AeonContentVariantProps, Pretty<DistributiveOmit<Props, keyof AeonContentVariantProps>>]
+  getVariantProps: (props?: AeonContentVariantProps) => AeonContentVariantProps
+}
+
+
+export declare const aeonContent: AeonContentRecipe

package/packages/panda/styled-system/recipes/aeon-content.mjs

@@ -0,0 +1,70 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonContentDefaultVariants = {
+  "align": "start"
+}
+const aeonContentCompoundVariants = []
+
+const aeonContentSlotNames = [
+  [
+    "root",
+    "aeonContent__root"
+  ],
+  [
+    "toolbar",
+    "aeonContent__toolbar"
+  ],
+  [
+    "body",
+    "aeonContent__body"
+  ],
+  [
+    "pending",
+    "aeonContent__pending"
+  ],
+  [
+    "empty",
+    "aeonContent__empty"
+  ],
+  [
+    "error",
+    "aeonContent__error"
+  ],
+  [
+    "success",
+    "aeonContent__success"
+  ],
+  [
+    "sentinel",
+    "aeonContent__sentinel"
+  ]
+]
+const aeonContentSlotFns = /* @__PURE__ */ aeonContentSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonContentDefaultVariants, getSlotCompoundVariant(aeonContentCompoundVariants, slotName))])
+
+const aeonContentFn = memo((props = {}) => {
+  return Object.fromEntries(aeonContentSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonContentVariantKeys = [
+  "align"
+]
+const getVariantProps = (variants) => ({ ...aeonContentDefaultVariants, ...compact(variants) })
+
+export const aeonContent = /* @__PURE__ */ Object.assign(aeonContentFn, {
+  __recipe__: false,
+  __name__: 'aeonContent',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: aeonContentVariantKeys,
+  variantMap: {
+  "align": [
+    "start",
+    "center"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, aeonContentVariantKeys)
+  },
+  getVariantProps
+})

package/packages/panda/styled-system/recipes/aeon-conversation.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonConversationVariant {
+  
+}
+
+type AeonConversationVariantMap = {
+  [key in keyof AeonConversationVariant]: Array<AeonConversationVariant[key]>
+}
+
+type AeonConversationSlot = "root" | "item" | "leading" | "body" | "title" | "preview" | "meta" | "badge"
+
+export type AeonConversationVariantProps = {
+  [key in keyof AeonConversationVariant]?: ConditionalValue<AeonConversationVariant[key]> | undefined
+}
+
+export interface AeonConversationRecipe {
+  __slot: AeonConversationSlot
+  __type: AeonConversationVariantProps
+  (props?: AeonConversationVariantProps): Pretty<Record<AeonConversationSlot, string>>
+  raw: (props?: AeonConversationVariantProps) => AeonConversationVariantProps
+  variantMap: AeonConversationVariantMap
+  variantKeys: Array<keyof AeonConversationVariant>
+  splitVariantProps<Props extends AeonConversationVariantProps>(props: Props): [AeonConversationVariantProps, Pretty<DistributiveOmit<Props, keyof AeonConversationVariantProps>>]
+  getVariantProps: (props?: AeonConversationVariantProps) => AeonConversationVariantProps
+}
+
+
+export declare const aeonConversation: AeonConversationRecipe

package/packages/panda/styled-system/recipes/aeon-conversation.mjs

@@ -0,0 +1,61 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonConversationDefaultVariants = {}
+const aeonConversationCompoundVariants = []
+
+const aeonConversationSlotNames = [
+  [
+    "root",
+    "aeonConversation__root"
+  ],
+  [
+    "item",
+    "aeonConversation__item"
+  ],
+  [
+    "leading",
+    "aeonConversation__leading"
+  ],
+  [
+    "body",
+    "aeonConversation__body"
+  ],
+  [
+    "title",
+    "aeonConversation__title"
+  ],
+  [
+    "preview",
+    "aeonConversation__preview"
+  ],
+  [
+    "meta",
+    "aeonConversation__meta"
+  ],
+  [
+    "badge",
+    "aeonConversation__badge"
+  ]
+]
+const aeonConversationSlotFns = /* @__PURE__ */ aeonConversationSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonConversationDefaultVariants, getSlotCompoundVariant(aeonConversationCompoundVariants, slotName))])
+
+const aeonConversationFn = memo((props = {}) => {
+  return Object.fromEntries(aeonConversationSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonConversationVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonConversationDefaultVariants, ...compact(variants) })
+
+export const aeonConversation = /* @__PURE__ */ Object.assign(aeonConversationFn, {
+  __recipe__: false,
+  __name__: 'aeonConversation',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: aeonConversationVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonConversationVariantKeys)
+  },
+  getVariantProps
+})

package/packages/panda/styled-system/recipes/aeon-dialog.d.ts

@@ -10,13 +10,16 @@ type AeonDialogVariantMap = {
   [key in keyof AeonDialogVariant]: Array<AeonDialogVariant[key]>
 }
 
+type AeonDialogSlot = "root" | "trigger" | "backdrop" | "positioner" | "content" | "title" | "description" | "closeTrigger"
+
 export type AeonDialogVariantProps = {
   [key in keyof AeonDialogVariant]?: ConditionalValue<AeonDialogVariant[key]> | undefined
 }
 
 export interface AeonDialogRecipe {
+  __slot: AeonDialogSlot
   __type: AeonDialogVariantProps
-  (props?: AeonDialogVariantProps): Pretty<Record<"root" | "trigger" | "backdrop" | "positioner" | "content" | "title" | "description" | "closeTrigger", string>>
+  (props?: AeonDialogVariantProps): Pretty<Record<AeonDialogSlot, string>>
   raw: (props?: AeonDialogVariantProps) => AeonDialogVariantProps
   variantMap: AeonDialogVariantMap
   variantKeys: Array<keyof AeonDialogVariant>

package/packages/panda/styled-system/recipes/aeon-dialog.mjs

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

package/packages/panda/styled-system/recipes/aeon-entry.d.ts

@@ -0,0 +1,38 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonEntryVariant {
+  /**
+ * @default "compact"
+ */
+density: "compact" | "cozy"
+/**
+ * @default "stack"
+ */
+layout: "stack" | "split"
+}
+
+type AeonEntryVariantMap = {
+  [key in keyof AeonEntryVariant]: Array<AeonEntryVariant[key]>
+}
+
+type AeonEntrySlot = "list" | "root" | "header" | "leading" | "heading" | "title" | "subtitle" | "meta" | "media" | "body" | "values" | "value" | "actions" | "footer"
+
+export type AeonEntryVariantProps = {
+  [key in keyof AeonEntryVariant]?: ConditionalValue<AeonEntryVariant[key]> | undefined
+}
+
+export interface AeonEntryRecipe {
+  __slot: AeonEntrySlot
+  __type: AeonEntryVariantProps
+  (props?: AeonEntryVariantProps): Pretty<Record<AeonEntrySlot, string>>
+  raw: (props?: AeonEntryVariantProps) => AeonEntryVariantProps
+  variantMap: AeonEntryVariantMap
+  variantKeys: Array<keyof AeonEntryVariant>
+  splitVariantProps<Props extends AeonEntryVariantProps>(props: Props): [AeonEntryVariantProps, Pretty<DistributiveOmit<Props, keyof AeonEntryVariantProps>>]
+  getVariantProps: (props?: AeonEntryVariantProps) => AeonEntryVariantProps
+}
+
+
+export declare const aeonEntry: AeonEntryRecipe

package/packages/panda/styled-system/recipes/aeon-entry.mjs

@@ -0,0 +1,100 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonEntryDefaultVariants = {
+  "density": "compact",
+  "layout": "stack"
+}
+const aeonEntryCompoundVariants = []
+
+const aeonEntrySlotNames = [
+  [
+    "list",
+    "aeonEntry__list"
+  ],
+  [
+    "root",
+    "aeonEntry__root"
+  ],
+  [
+    "header",
+    "aeonEntry__header"
+  ],
+  [
+    "leading",
+    "aeonEntry__leading"
+  ],
+  [
+    "heading",
+    "aeonEntry__heading"
+  ],
+  [
+    "title",
+    "aeonEntry__title"
+  ],
+  [
+    "subtitle",
+    "aeonEntry__subtitle"
+  ],
+  [
+    "meta",
+    "aeonEntry__meta"
+  ],
+  [
+    "media",
+    "aeonEntry__media"
+  ],
+  [
+    "body",
+    "aeonEntry__body"
+  ],
+  [
+    "values",
+    "aeonEntry__values"
+  ],
+  [
+    "value",
+    "aeonEntry__value"
+  ],
+  [
+    "actions",
+    "aeonEntry__actions"
+  ],
+  [
+    "footer",
+    "aeonEntry__footer"
+  ]
+]
+const aeonEntrySlotFns = /* @__PURE__ */ aeonEntrySlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonEntryDefaultVariants, getSlotCompoundVariant(aeonEntryCompoundVariants, slotName))])
+
+const aeonEntryFn = memo((props = {}) => {
+  return Object.fromEntries(aeonEntrySlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonEntryVariantKeys = [
+  "density",
+  "layout"
+]
+const getVariantProps = (variants) => ({ ...aeonEntryDefaultVariants, ...compact(variants) })
+
+export const aeonEntry = /* @__PURE__ */ Object.assign(aeonEntryFn, {
+  __recipe__: false,
+  __name__: 'aeonEntry',
+  raw: (props) => props,
+  classNameMap: {},
+  variantKeys: aeonEntryVariantKeys,
+  variantMap: {
+  "density": [
+    "compact",
+    "cozy"
+  ],
+  "layout": [
+    "stack",
+    "split"
+  ]
+},
+  splitVariantProps(props) {
+    return splitProps(props, aeonEntryVariantKeys)
+  },
+  getVariantProps
+})