aeon-ui-engine 1.0.0

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

@@ -0,0 +1,37 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const aeonButtonGroupFn = /* @__PURE__ */ createRecipe('aeonButtonGroup', {
+  "orientation": "horizontal",
+  "gap": "sm"
+}, [])
+
+const aeonButtonGroupVariantMap = {
+  "orientation": [
+    "horizontal",
+    "vertical"
+  ],
+  "gap": [
+    "sm",
+    "md",
+    "lg"
+  ]
+}
+
+const aeonButtonGroupVariantKeys = Object.keys(aeonButtonGroupVariantMap)
+
+export const aeonButtonGroup = /* @__PURE__ */ Object.assign(memo(aeonButtonGroupFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'aeonButtonGroup',
+  __getCompoundVariantCss__: aeonButtonGroupFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: aeonButtonGroupVariantKeys,
+  variantMap: aeonButtonGroupVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, aeonButtonGroupVariantKeys)
+  },
+  getVariantProps: aeonButtonGroupFn.getVariantProps,
+})

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

@@ -0,0 +1,39 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonButtonVariant {
+  /**
+ * @default "solid"
+ */
+variant: "solid" | "outline" | "ghost"
+/**
+ * @default "sm"
+ */
+size: "xs" | "sm" | "md" | "lg"
+}
+
+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
+  variantMap: AeonButtonVariantMap
+  variantKeys: Array<keyof AeonButtonVariant>
+  splitVariantProps<Props extends AeonButtonVariantProps>(props: Props): [AeonButtonVariantProps, Pretty<DistributiveOmit<Props, keyof AeonButtonVariantProps>>]
+  getVariantProps: (props?: AeonButtonVariantProps) => AeonButtonVariantProps
+}
+
+/**
+ * Aeon button styles
+
+
+ */
+export declare const aeonButton: AeonButtonRecipe

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

@@ -0,0 +1,39 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const aeonButtonFn = /* @__PURE__ */ createRecipe('aeonButton', {
+  "variant": "solid",
+  "size": "sm"
+}, [])
+
+const aeonButtonVariantMap = {
+  "variant": [
+    "solid",
+    "outline",
+    "ghost"
+  ],
+  "size": [
+    "xs",
+    "sm",
+    "md",
+    "lg"
+  ]
+}
+
+const aeonButtonVariantKeys = Object.keys(aeonButtonVariantMap)
+
+export const aeonButton = /* @__PURE__ */ Object.assign(memo(aeonButtonFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'aeonButton',
+  __getCompoundVariantCss__: aeonButtonFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: aeonButtonVariantKeys,
+  variantMap: aeonButtonVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, aeonButtonVariantKeys)
+  },
+  getVariantProps: aeonButtonFn.getVariantProps,
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonCheckboxVariant {
+  
+}
+
+type AeonCheckboxVariantMap = {
+  [key in keyof AeonCheckboxVariant]: Array<AeonCheckboxVariant[key]>
+}
+
+export type AeonCheckboxVariantProps = {
+  [key in keyof AeonCheckboxVariant]?: ConditionalValue<AeonCheckboxVariant[key]> | undefined
+}
+
+export interface AeonCheckboxRecipe {
+  __type: AeonCheckboxVariantProps
+  (props?: AeonCheckboxVariantProps): Pretty<Record<"root" | "control" | "indicator" | "label" | "hiddenInput", string>>
+  raw: (props?: AeonCheckboxVariantProps) => AeonCheckboxVariantProps
+  variantMap: AeonCheckboxVariantMap
+  variantKeys: Array<keyof AeonCheckboxVariant>
+  splitVariantProps<Props extends AeonCheckboxVariantProps>(props: Props): [AeonCheckboxVariantProps, Pretty<DistributiveOmit<Props, keyof AeonCheckboxVariantProps>>]
+  getVariantProps: (props?: AeonCheckboxVariantProps) => AeonCheckboxVariantProps
+}
+
+
+export declare const aeonCheckbox: AeonCheckboxRecipe

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

@@ -0,0 +1,48 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonCheckboxDefaultVariants = {}
+const aeonCheckboxCompoundVariants = []
+
+const aeonCheckboxSlotNames = [
+  [
+    "root",
+    "aeonCheckbox__root"
+  ],
+  [
+    "control",
+    "aeonCheckbox__control"
+  ],
+  [
+    "indicator",
+    "aeonCheckbox__indicator"
+  ],
+  [
+    "label",
+    "aeonCheckbox__label"
+  ],
+  [
+    "hiddenInput",
+    "aeonCheckbox__hiddenInput"
+  ]
+]
+const aeonCheckboxSlotFns = /* @__PURE__ */ aeonCheckboxSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonCheckboxDefaultVariants, getSlotCompoundVariant(aeonCheckboxCompoundVariants, slotName))])
+
+const aeonCheckboxFn = memo((props = {}) => {
+  return Object.fromEntries(aeonCheckboxSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonCheckboxVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonCheckboxDefaultVariants, ...compact(variants) })
+
+export const aeonCheckbox = /* @__PURE__ */ Object.assign(aeonCheckboxFn, {
+  __recipe__: false,
+  __name__: 'aeonCheckbox',
+  raw: (props) => props,
+  variantKeys: aeonCheckboxVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonCheckboxVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,32 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonComboboxVariant {
+  
+}
+
+type AeonComboboxVariantMap = {
+  [key in keyof AeonComboboxVariant]: Array<AeonComboboxVariant[key]>
+}
+
+export type AeonComboboxVariantProps = {
+  [key in keyof AeonComboboxVariant]?: ConditionalValue<AeonComboboxVariant[key]> | undefined
+}
+
+export interface AeonComboboxRecipe {
+  __type: AeonComboboxVariantProps
+  (props?: AeonComboboxVariantProps): Pretty<Record<"root" | "input" | "icon" | "content" | "item" | "empty", string>>
+  raw: (props?: AeonComboboxVariantProps) => AeonComboboxVariantProps
+  variantMap: AeonComboboxVariantMap
+  variantKeys: Array<keyof AeonComboboxVariant>
+  splitVariantProps<Props extends AeonComboboxVariantProps>(props: Props): [AeonComboboxVariantProps, Pretty<DistributiveOmit<Props, keyof AeonComboboxVariantProps>>]
+  getVariantProps: (props?: AeonComboboxVariantProps) => AeonComboboxVariantProps
+}
+
+/**
+ * Filterable combobox — input + listbox (extends select patterns)
+
+
+ */
+export declare const aeonCombobox: AeonComboboxRecipe

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

@@ -0,0 +1,52 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonComboboxDefaultVariants = {}
+const aeonComboboxCompoundVariants = []
+
+const aeonComboboxSlotNames = [
+  [
+    "root",
+    "aeonCombobox__root"
+  ],
+  [
+    "input",
+    "aeonCombobox__input"
+  ],
+  [
+    "icon",
+    "aeonCombobox__icon"
+  ],
+  [
+    "content",
+    "aeonCombobox__content"
+  ],
+  [
+    "item",
+    "aeonCombobox__item"
+  ],
+  [
+    "empty",
+    "aeonCombobox__empty"
+  ]
+]
+const aeonComboboxSlotFns = /* @__PURE__ */ aeonComboboxSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonComboboxDefaultVariants, getSlotCompoundVariant(aeonComboboxCompoundVariants, slotName))])
+
+const aeonComboboxFn = memo((props = {}) => {
+  return Object.fromEntries(aeonComboboxSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonComboboxVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonComboboxDefaultVariants, ...compact(variants) })
+
+export const aeonCombobox = /* @__PURE__ */ Object.assign(aeonComboboxFn, {
+  __recipe__: false,
+  __name__: 'aeonCombobox',
+  raw: (props) => props,
+  variantKeys: aeonComboboxVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonComboboxVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonDialogVariant {
+  
+}
+
+type AeonDialogVariantMap = {
+  [key in keyof AeonDialogVariant]: Array<AeonDialogVariant[key]>
+}
+
+export type AeonDialogVariantProps = {
+  [key in keyof AeonDialogVariant]?: ConditionalValue<AeonDialogVariant[key]> | undefined
+}
+
+export interface AeonDialogRecipe {
+  __type: AeonDialogVariantProps
+  (props?: AeonDialogVariantProps): Pretty<Record<"root" | "trigger" | "backdrop" | "positioner" | "content" | "title" | "description" | "closeTrigger", string>>
+  raw: (props?: AeonDialogVariantProps) => AeonDialogVariantProps
+  variantMap: AeonDialogVariantMap
+  variantKeys: Array<keyof AeonDialogVariant>
+  splitVariantProps<Props extends AeonDialogVariantProps>(props: Props): [AeonDialogVariantProps, Pretty<DistributiveOmit<Props, keyof AeonDialogVariantProps>>]
+  getVariantProps: (props?: AeonDialogVariantProps) => AeonDialogVariantProps
+}
+
+
+export declare const aeonDialog: AeonDialogRecipe

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

@@ -0,0 +1,60 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonDialogDefaultVariants = {}
+const aeonDialogCompoundVariants = []
+
+const aeonDialogSlotNames = [
+  [
+    "root",
+    "aeonDialog__root"
+  ],
+  [
+    "trigger",
+    "aeonDialog__trigger"
+  ],
+  [
+    "backdrop",
+    "aeonDialog__backdrop"
+  ],
+  [
+    "positioner",
+    "aeonDialog__positioner"
+  ],
+  [
+    "content",
+    "aeonDialog__content"
+  ],
+  [
+    "title",
+    "aeonDialog__title"
+  ],
+  [
+    "description",
+    "aeonDialog__description"
+  ],
+  [
+    "closeTrigger",
+    "aeonDialog__closeTrigger"
+  ]
+]
+const aeonDialogSlotFns = /* @__PURE__ */ aeonDialogSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonDialogDefaultVariants, getSlotCompoundVariant(aeonDialogCompoundVariants, slotName))])
+
+const aeonDialogFn = memo((props = {}) => {
+  return Object.fromEntries(aeonDialogSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonDialogVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonDialogDefaultVariants, ...compact(variants) })
+
+export const aeonDialog = /* @__PURE__ */ Object.assign(aeonDialogFn, {
+  __recipe__: false,
+  __name__: 'aeonDialog',
+  raw: (props) => props,
+  variantKeys: aeonDialogVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonDialogVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,32 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonFieldVariant {
+  
+}
+
+type AeonFieldVariantMap = {
+  [key in keyof AeonFieldVariant]: Array<AeonFieldVariant[key]>
+}
+
+export type AeonFieldVariantProps = {
+  [key in keyof AeonFieldVariant]?: ConditionalValue<AeonFieldVariant[key]> | undefined
+}
+
+export interface AeonFieldRecipe {
+  __type: AeonFieldVariantProps
+  (props?: AeonFieldVariantProps): Pretty<Record<"root" | "label" | "control" | "textarea" | "message" | "hint", string>>
+  raw: (props?: AeonFieldVariantProps) => AeonFieldVariantProps
+  variantMap: AeonFieldVariantMap
+  variantKeys: Array<keyof AeonFieldVariant>
+  splitVariantProps<Props extends AeonFieldVariantProps>(props: Props): [AeonFieldVariantProps, Pretty<DistributiveOmit<Props, keyof AeonFieldVariantProps>>]
+  getVariantProps: (props?: AeonFieldVariantProps) => AeonFieldVariantProps
+}
+
+/**
+ * Form field with orthogonal interaction, validation, and submission states
+
+
+ */
+export declare const aeonField: AeonFieldRecipe

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

@@ -0,0 +1,52 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonFieldDefaultVariants = {}
+const aeonFieldCompoundVariants = []
+
+const aeonFieldSlotNames = [
+  [
+    "root",
+    "aeonField__root"
+  ],
+  [
+    "label",
+    "aeonField__label"
+  ],
+  [
+    "control",
+    "aeonField__control"
+  ],
+  [
+    "textarea",
+    "aeonField__textarea"
+  ],
+  [
+    "message",
+    "aeonField__message"
+  ],
+  [
+    "hint",
+    "aeonField__hint"
+  ]
+]
+const aeonFieldSlotFns = /* @__PURE__ */ aeonFieldSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonFieldDefaultVariants, getSlotCompoundVariant(aeonFieldCompoundVariants, slotName))])
+
+const aeonFieldFn = memo((props = {}) => {
+  return Object.fromEntries(aeonFieldSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonFieldVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonFieldDefaultVariants, ...compact(variants) })
+
+export const aeonField = /* @__PURE__ */ Object.assign(aeonFieldFn, {
+  __recipe__: false,
+  __name__: 'aeonField',
+  raw: (props) => props,
+  variantKeys: aeonFieldVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonFieldVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonMenuVariant {
+  
+}
+
+type AeonMenuVariantMap = {
+  [key in keyof AeonMenuVariant]: Array<AeonMenuVariant[key]>
+}
+
+export type AeonMenuVariantProps = {
+  [key in keyof AeonMenuVariant]?: ConditionalValue<AeonMenuVariant[key]> | undefined
+}
+
+export interface AeonMenuRecipe {
+  __type: AeonMenuVariantProps
+  (props?: AeonMenuVariantProps): Pretty<Record<"root" | "trigger" | "positioner" | "content" | "item" | "separator", string>>
+  raw: (props?: AeonMenuVariantProps) => AeonMenuVariantProps
+  variantMap: AeonMenuVariantMap
+  variantKeys: Array<keyof AeonMenuVariant>
+  splitVariantProps<Props extends AeonMenuVariantProps>(props: Props): [AeonMenuVariantProps, Pretty<DistributiveOmit<Props, keyof AeonMenuVariantProps>>]
+  getVariantProps: (props?: AeonMenuVariantProps) => AeonMenuVariantProps
+}
+
+
+export declare const aeonMenu: AeonMenuRecipe

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

@@ -0,0 +1,52 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonMenuDefaultVariants = {}
+const aeonMenuCompoundVariants = []
+
+const aeonMenuSlotNames = [
+  [
+    "root",
+    "aeonMenu__root"
+  ],
+  [
+    "trigger",
+    "aeonMenu__trigger"
+  ],
+  [
+    "positioner",
+    "aeonMenu__positioner"
+  ],
+  [
+    "content",
+    "aeonMenu__content"
+  ],
+  [
+    "item",
+    "aeonMenu__item"
+  ],
+  [
+    "separator",
+    "aeonMenu__separator"
+  ]
+]
+const aeonMenuSlotFns = /* @__PURE__ */ aeonMenuSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonMenuDefaultVariants, getSlotCompoundVariant(aeonMenuCompoundVariants, slotName))])
+
+const aeonMenuFn = memo((props = {}) => {
+  return Object.fromEntries(aeonMenuSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonMenuVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonMenuDefaultVariants, ...compact(variants) })
+
+export const aeonMenu = /* @__PURE__ */ Object.assign(aeonMenuFn, {
+  __recipe__: false,
+  __name__: 'aeonMenu',
+  raw: (props) => props,
+  variantKeys: aeonMenuVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonMenuVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonPopoverVariant {
+  
+}
+
+type AeonPopoverVariantMap = {
+  [key in keyof AeonPopoverVariant]: Array<AeonPopoverVariant[key]>
+}
+
+export type AeonPopoverVariantProps = {
+  [key in keyof AeonPopoverVariant]?: ConditionalValue<AeonPopoverVariant[key]> | undefined
+}
+
+export interface AeonPopoverRecipe {
+  __type: AeonPopoverVariantProps
+  (props?: AeonPopoverVariantProps): Pretty<Record<"root" | "trigger" | "positioner" | "content" | "arrow" | "closeTrigger", string>>
+  raw: (props?: AeonPopoverVariantProps) => AeonPopoverVariantProps
+  variantMap: AeonPopoverVariantMap
+  variantKeys: Array<keyof AeonPopoverVariant>
+  splitVariantProps<Props extends AeonPopoverVariantProps>(props: Props): [AeonPopoverVariantProps, Pretty<DistributiveOmit<Props, keyof AeonPopoverVariantProps>>]
+  getVariantProps: (props?: AeonPopoverVariantProps) => AeonPopoverVariantProps
+}
+
+
+export declare const aeonPopover: AeonPopoverRecipe

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

@@ -0,0 +1,52 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const aeonPopoverDefaultVariants = {}
+const aeonPopoverCompoundVariants = []
+
+const aeonPopoverSlotNames = [
+  [
+    "root",
+    "aeonPopover__root"
+  ],
+  [
+    "trigger",
+    "aeonPopover__trigger"
+  ],
+  [
+    "positioner",
+    "aeonPopover__positioner"
+  ],
+  [
+    "content",
+    "aeonPopover__content"
+  ],
+  [
+    "arrow",
+    "aeonPopover__arrow"
+  ],
+  [
+    "closeTrigger",
+    "aeonPopover__closeTrigger"
+  ]
+]
+const aeonPopoverSlotFns = /* @__PURE__ */ aeonPopoverSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, aeonPopoverDefaultVariants, getSlotCompoundVariant(aeonPopoverCompoundVariants, slotName))])
+
+const aeonPopoverFn = memo((props = {}) => {
+  return Object.fromEntries(aeonPopoverSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const aeonPopoverVariantKeys = []
+const getVariantProps = (variants) => ({ ...aeonPopoverDefaultVariants, ...compact(variants) })
+
+export const aeonPopover = /* @__PURE__ */ Object.assign(aeonPopoverFn, {
+  __recipe__: false,
+  __name__: 'aeonPopover',
+  raw: (props) => props,
+  variantKeys: aeonPopoverVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, aeonPopoverVariantKeys)
+  },
+  getVariantProps
+})

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

@@ -0,0 +1,43 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface AeonScrollVariant {
+  /**
+ * @default "both"
+ */
+axis: "y" | "x" | "both"
+/**
+ * @default "md"
+ */
+maxH: "sm" | "md" | "lg"
+/**
+ * @default "full"
+ */
+maxW: "full" | "md"
+}
+
+type AeonScrollVariantMap = {
+  [key in keyof AeonScrollVariant]: Array<AeonScrollVariant[key]>
+}
+
+export type AeonScrollVariantProps = {
+  [key in keyof AeonScrollVariant]?: ConditionalValue<AeonScrollVariant[key]> | undefined
+}
+
+export interface AeonScrollRecipe {
+  __type: AeonScrollVariantProps
+  (props?: AeonScrollVariantProps): Pretty<Record<"root" | "viewport" | "content", string>>
+  raw: (props?: AeonScrollVariantProps) => AeonScrollVariantProps
+  variantMap: AeonScrollVariantMap
+  variantKeys: Array<keyof AeonScrollVariant>
+  splitVariantProps<Props extends AeonScrollVariantProps>(props: Props): [AeonScrollVariantProps, Pretty<DistributiveOmit<Props, keyof AeonScrollVariantProps>>]
+  getVariantProps: (props?: AeonScrollVariantProps) => AeonScrollVariantProps
+}
+
+/**
+ * Scroll viewport with axis + edge states on data-aeon-state
+
+
+ */
+export declare const aeonScroll: AeonScrollRecipe