mainbase-ui 1.2.5-b → 3.36.0

package/dist/types/hooks/use-overlay.d.ts

@@ -0,0 +1,46 @@
+import * as React from "react";
+import { type Dict } from "../utils";
+/**
+ * Props that are injected into the overlay component by the `createOverlay` function.
+ * These props are used to control the overlay's state and lifecycle.
+ */
+export interface CreateOverlayProps {
+    /** Whether the overlay is currently open */
+    open?: boolean;
+    /** Callback fired when the overlay's open state changes */
+    onOpenChange?: (e: {
+        open: boolean;
+    }) => void;
+    /** Callback fired when the overlay's exit animation completes */
+    onExitComplete?: () => void;
+    /** Internal callback used to set the return value when the overlay closes */
+    setReturnValue?: ((value: unknown) => void) | undefined;
+    /** Internal callback used to signal when the exit animation is complete */
+    setExitComplete?: (() => void) | undefined;
+}
+export interface OverlayOptions<T extends CreateOverlayProps> {
+    props?: T;
+}
+export interface CreateOverlayReturn<T extends CreateOverlayProps> {
+    /** The root component for the overlay */
+    Viewport: React.ElementType;
+    /** Opens a new overlay with the given id and props */
+    open: (id: string, props: T) => Promise<any>;
+    /** Closes the overlay with the given id and returns the value */
+    close: (id: string, value?: any) => Promise<void>;
+    /** Updates the props of the overlay with the given id */
+    update: (id: string, props: T) => void;
+    /** Removes the overlay with the given id */
+    remove: (id: string) => void;
+    /** Removes all overlays */
+    removeAll: () => void;
+    /** Gets the props of the overlay with the given id */
+    get: (id: string) => T;
+    /** Checks if the overlay with the given id exists */
+    has: (id: string) => boolean;
+    /** Gets the current snapshot of the overlays */
+    getSnapshot: () => T[];
+    /** Waits for the exit animation to complete for the overlay with the given id */
+    waitForExit: (id: string) => Promise<void>;
+}
+export declare function createOverlay<T extends Dict>(Component: React.ComponentType<T & CreateOverlayProps>, options?: OverlayOptions<T>): CreateOverlayReturn<T>;

package/dist/types/hooks/use-previous.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @see https://react.dev/reference/react/useState#storing-information-from-previous-renders
+ */
+export declare function usePrevious<T>(value: T): T | undefined;

package/dist/types/hooks/use-safe-layout-effect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from "react";
+export declare const useSafeLayoutEffect: typeof useEffect;

package/dist/types/hooks/use-update-effect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from "react";
+export declare const useUpdateEffect: typeof useEffect;

package/dist/types/index.d.mts

@@ -0,0 +1,9 @@
+export * from "./collection";
+export * from "./components";
+export { createContext } from "./create-context";
+export * from "./hooks";
+export { mergeProps } from "./merge-props";
+export { mergeRefs } from "./merge-refs";
+export { defaultConfig, defaultSystem } from "./preset";
+export { defaultBaseConfig } from "./preset-base";
+export * from "./styled-system";

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./collection";
+export * from "./components";
+export { createContext } from "./create-context";
+export * from "./hooks";
+export { mergeProps } from "./merge-props";
+export { mergeRefs } from "./merge-refs";
+export { defaultConfig, defaultSystem } from "./preset";
+export { defaultBaseConfig } from "./preset-base";
+export * from "./styled-system";

package/dist/types/merge-props.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    [key: string]: any;
+}
+type TupleTypes<T extends any[]> = T[number];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export declare function mergeProps<T extends Props>(...args: T[]): UnionToIntersection<TupleTypes<T[]>>;
+export {};

package/dist/types/merge-refs.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+type StrictRef<T> = NonNullable<React.Ref<T>>;
+type RefCleanup<T> = ReturnType<React.RefCallback<T>>;
+export declare function assignRef<T = any>(ref: StrictRef<T>, value: T | null): RefCleanup<T>;
+export declare function mergeRefs<T>(...refs: (React.Ref<T> | undefined)[]): React.RefCallback<T>;
+export {};

package/dist/types/preset-base.d.ts

@@ -0,0 +1,107 @@
+export declare const defaultConditions: {
+    hover: string[];
+    active: string;
+    focus: string;
+    focusWithin: string;
+    focusVisible: string;
+    disabled: string;
+    visited: string;
+    target: string;
+    readOnly: string;
+    readWrite: string;
+    empty: string;
+    checked: string;
+    enabled: string;
+    expanded: string;
+    highlighted: string;
+    complete: string;
+    incomplete: string;
+    dragging: string;
+    before: string;
+    after: string;
+    firstLetter: string;
+    firstLine: string;
+    marker: string;
+    selection: string;
+    file: string;
+    backdrop: string;
+    first: string;
+    last: string;
+    notFirst: string;
+    notLast: string;
+    only: string;
+    even: string;
+    odd: string;
+    peerFocus: string;
+    peerHover: string;
+    peerActive: string;
+    peerFocusWithin: string;
+    peerFocusVisible: string;
+    peerDisabled: string;
+    peerChecked: string;
+    peerInvalid: string;
+    peerExpanded: string;
+    peerPlaceholderShown: string;
+    groupFocus: string;
+    groupHover: string;
+    groupActive: string;
+    groupFocusWithin: string;
+    groupFocusVisible: string;
+    groupDisabled: string;
+    groupChecked: string;
+    groupExpanded: string;
+    groupInvalid: string;
+    indeterminate: string;
+    required: string;
+    valid: string;
+    invalid: string;
+    autofill: string;
+    inRange: string;
+    outOfRange: string;
+    placeholder: string;
+    placeholderShown: string;
+    pressed: string;
+    selected: string;
+    grabbed: string;
+    underValue: string;
+    overValue: string;
+    atValue: string;
+    default: string;
+    optional: string;
+    open: string;
+    closed: string;
+    fullscreen: string;
+    loading: string;
+    hidden: string;
+    current: string;
+    currentPage: string;
+    currentStep: string;
+    today: string;
+    unavailable: string;
+    rangeStart: string;
+    rangeEnd: string;
+    now: string;
+    topmost: string;
+    motionReduce: string;
+    motionSafe: string;
+    print: string;
+    landscape: string;
+    portrait: string;
+    dark: string;
+    light: string;
+    osDark: string;
+    osLight: string;
+    highContrast: string;
+    lessContrast: string;
+    moreContrast: string;
+    ltr: string;
+    rtl: string;
+    scrollbar: string;
+    scrollbarThumb: string;
+    scrollbarTrack: string;
+    horizontal: string;
+    vertical: string;
+    icon: string;
+    starting: string;
+};
+export declare const defaultBaseConfig: import("./styled-system").SystemConfig;

package/dist/types/preset.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultConfig: import("./styled-system").SystemConfig;
+export declare const defaultSystem: import("./styled-system").SystemContext;
+export { defaultSystem as system };

package/dist/types/styled-system/breakpoints.d.ts

@@ -0,0 +1,2 @@
+import type { SystemContext } from "./types";
+export declare function createBreakpoints(breakpoints: Record<string, string>): SystemContext["breakpoints"];

package/dist/types/styled-system/calc.d.ts

@@ -0,0 +1,19 @@
+export type Operand = string | number | {
+    reference: string;
+};
+interface CalcChain {
+    add: (...operands: Array<Operand>) => CalcChain;
+    subtract: (...operands: Array<Operand>) => CalcChain;
+    multiply: (...operands: Array<Operand>) => CalcChain;
+    divide: (...operands: Array<Operand>) => CalcChain;
+    negate: () => CalcChain;
+    toString: () => string;
+}
+export declare const calc: ((x: Operand) => CalcChain) & {
+    add: (...operands: Array<Operand>) => string;
+    subtract: (...operands: Array<Operand>) => string;
+    multiply: (...operands: Array<Operand>) => string;
+    divide: (...operands: Array<Operand>) => string;
+    negate: (x: Operand) => string;
+};
+export {};

package/dist/types/styled-system/color-mix.d.ts

@@ -0,0 +1,11 @@
+import type { PropertyTransform, TransformArgs } from "./types";
+export declare const colorMix: (value: string, token: TransformArgs["token"]) => {
+    invalid: boolean;
+    value: string;
+    color?: undefined;
+} | {
+    invalid: boolean;
+    color: string;
+    value: string;
+};
+export declare const createColorMixTransform: (prop: string) => PropertyTransform;

package/dist/types/styled-system/composition.d.ts

@@ -0,0 +1,27 @@
+import type { CompositionStyleObject } from "./css.types";
+interface Token<T> {
+    value: T;
+    description?: string | undefined;
+}
+interface Recursive<T> {
+    [key: string]: Recursive<T> | T;
+}
+type TextStyleProperty = "color" | "direction" | "font" | "fontFamily" | "fontFeatureSettings" | "fontKerning" | "fontLanguageOverride" | "fontOpticalSizing" | "fontPalette" | "fontSize" | "fontSizeAdjust" | "fontStretch" | "fontStyle" | "fontSynthesis" | "fontVariant" | "fontVariantAlternates" | "fontVariantCaps" | "fontVariantLigatures" | "fontVariantNumeric" | "fontVariantPosition" | "fontVariationSettings" | "fontWeight" | "hangingPunctuation" | "hyphens" | "hyphenateCharacter" | "hyphenateLimitChars" | "letterSpacing" | "lineBreak" | "lineHeight" | "quotes" | "overflowWrap" | "tabSize" | "textAlign" | "textAlignLast" | "textCombineUpright" | "textDecoration" | "textDecorationColor" | "textDecorationLine" | "textDecorationSkip" | "textDecorationSkipBox" | "textDecorationSkipInk" | "textDecorationSkipInset" | "textDecorationStyle" | "textDecorationThickness" | "textEmphasis" | "textEmphasisColor" | "textEmphasisPosition" | "textEmphasisStyle" | "textIndent" | "textJustify" | "textOrientation" | "textOverflow" | "textRendering" | "textShadow" | "textStroke" | "textStrokeColor" | "textStrokeWidth" | "textTransform" | "textUnderlineOffset" | "textUnderlinePosition" | "textWrap" | "textWrapMode" | "textWrapStyle" | "unicodeBidi" | "verticalAlign" | "whiteSpace" | "wordBreak" | "wordSpacing" | "writingMode";
+export type TextStyle = CompositionStyleObject<TextStyleProperty>;
+export type TextStyles = Recursive<Token<TextStyle>>;
+type LogicalPlacement = "Inline" | "Block" | "InlineStart" | "InlineEnd" | "BlockStart" | "BlockEnd";
+type PhysicalPlacement = "Top" | "Right" | "Bottom" | "Left";
+type Placement = PhysicalPlacement | LogicalPlacement;
+type Radius = `Top${"Right" | "Left"}` | `Bottom${"Right" | "Left"}` | `Start${"Start" | "End"}` | `End${"Start" | "End"}`;
+type LayerStyleProperty = "aspectRatio" | "background" | "bg" | "backgroundColor" | "bgColor" | "backgroundImage" | "bgImage" | "backgroundBlendMode" | "backgroundAttachment" | "backgroundClip" | "backgroundOrigin" | "backgroundPosition" | "backgroundRepeat" | "backgroundSize" | "border" | "borderColor" | "borderImage" | "borderImageOutset" | "borderImageRepeat" | "borderImageSlice" | "borderImageSource" | "borderImageWidth" | `border${Placement}` | `border${Placement}Color` | `border${Placement}Style` | `border${Placement}Width` | "borderRadius" | `border${Radius}Radius` | "borderStyle" | "borderWidth" | "boxShadow" | "boxShadowColor" | "clipPath" | "color" | "contain" | "content" | "contentVisibility" | "cursor" | "display" | "filter" | "backdropFilter" | "height" | "width" | "minHeight" | "minWidth" | "maxHeight" | "maxWidth" | `margin${Placement}` | "inset" | `inset${LogicalPlacement}` | Lowercase<PhysicalPlacement> | "isolation" | "mask" | "maskClip" | "maskComposite" | "maskImage" | "maskMode" | "maskOrigin" | "maskPosition" | "maskRepeat" | "maskSize" | "mixBlendMode" | "objectFit" | "objectPosition" | "opacity" | "outline" | "outlineColor" | "outlineOffset" | "outlineStyle" | "outlineWidth" | "overflow" | "overflowX" | "overflowY" | "padding" | `padding${Placement}` | "pointerEvents" | "position" | "resize" | "transform" | "transition" | "visibility" | "willChange" | "zIndex";
+export type LayerStyle = CompositionStyleObject<LayerStyleProperty>;
+export type LayerStyles = Recursive<Token<LayerStyle>>;
+type AnimationStyleProperty = "animation" | "animationComposition" | "animationDelay" | "animationDirection" | "animationDuration" | "animationFillMode" | "animationIterationCount" | "animationName" | "animationPlayState" | "animationTimingFunction" | "animationRange" | "animationRangeStart" | "animationRangeEnd" | "animationTimeline" | "transformOrigin";
+export type AnimationStyle = CompositionStyleObject<AnimationStyleProperty>;
+export type AnimationStyles = Recursive<Token<AnimationStyle>>;
+export interface CompositionStyles {
+    textStyles: TextStyles;
+    layerStyles: LayerStyles;
+    animationStyles: AnimationStyles;
+}
+export {};

package/dist/types/styled-system/conditions.d.ts

@@ -0,0 +1,2 @@
+import type { Condition, ConditionConfig } from "./types";
+export declare const createConditions: (options: ConditionConfig) => Condition;

package/dist/types/styled-system/config.d.ts

@@ -0,0 +1,22 @@
+import type { CompositionStyles } from "./composition";
+import type { GlobalStyleIdentityFn, KeyframeIdentityFn, SystemStyleIdentityFn } from "./css.types";
+import type { RecipeIdentityFn, SlotRecipeIdentityFn } from "./recipe.types";
+import type { ConditionRecord, SemanticTokenDefinition, SystemConfig, TokenDefinition } from "./types";
+export declare const defineConditions: <T extends ConditionRecord>(v: T) => T;
+export declare const defineRecipe: RecipeIdentityFn;
+export declare const defineSlotRecipe: SlotRecipeIdentityFn;
+export declare const defineKeyframes: KeyframeIdentityFn;
+export declare const defineGlobalStyles: GlobalStyleIdentityFn;
+export declare const defineStyle: SystemStyleIdentityFn;
+export declare const defineTextStyles: (v: CompositionStyles["textStyles"]) => import("./composition").TextStyles;
+export declare const defineAnimationStyles: (v: CompositionStyles["animationStyles"]) => import("./composition").AnimationStyles;
+export declare const defineLayerStyles: (v: CompositionStyles["layerStyles"]) => import("./composition").LayerStyles;
+type ProxyValue<T> = {
+    <Value>(definition: Value extends T ? Value : T): Value;
+} & {
+    [K in keyof Required<T>]: <Value>(definition: Value extends T[K] ? Value : T[K]) => Value;
+};
+export declare const defineTokens: ProxyValue<TokenDefinition>;
+export declare const defineSemanticTokens: ProxyValue<SemanticTokenDefinition>;
+export declare const defineConfig: (v: SystemConfig) => SystemConfig;
+export { mergeConfigs } from "./merge-config";

package/dist/types/styled-system/create-recipe-context.d.ts

@@ -0,0 +1,17 @@
+import type { JsxFactoryOptions } from "./factory.types";
+import { type RecipeKey, type UseRecipeOptions } from "./use-recipe";
+export declare function createRecipeContext<K extends RecipeKey>(options: UseRecipeOptions<K>): {
+    withContext: <T, P>(Component: React.ElementType<any>, options?: JsxFactoryOptions<P>) => React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
+    PropsProvider: import("react").Provider<Record<string, any>>;
+    withPropsProvider: <P>() => React.Provider<Partial<P>>;
+    usePropsContext: () => Record<string, any>;
+    useRecipeResult: (props: any) => {
+        styles: Readonly<import("./css.types").SystemStyleObject>;
+        className: string;
+        props: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        };
+    };
+};

package/dist/types/styled-system/create-slot-recipe-context.d.ts

@@ -0,0 +1,36 @@
+import type { SystemStyleObject } from "./css.types";
+import type { JsxFactoryOptions } from "./factory.types";
+import type { ConfigRecipeSlots } from "./generated/recipes.gen";
+import { type SlotRecipeKey, type UseSlotRecipeOptions } from "./use-slot-recipe";
+interface WrapElementProps<P> {
+    wrapElement?(element: React.ReactElement, props: P): React.ReactElement;
+}
+export interface WithRootProviderOptions<P> extends WrapElementProps<P> {
+    defaultProps?: Partial<P> | undefined;
+    displayName?: string | undefined;
+}
+export interface WithProviderOptions<P> extends JsxFactoryOptions<P>, WrapElementProps<P> {
+}
+export interface WithContextOptions<P> extends JsxFactoryOptions<P> {
+}
+export declare const createSlotRecipeContext: <R extends SlotRecipeKey>(options: UseSlotRecipeOptions<R>) => {
+    StylesProvider: import("react").Provider<Record<string, SystemStyleObject>>;
+    ClassNamesProvider: import("react").Provider<Record<string, string>>;
+    PropsProvider: import("react").Provider<Record<string, any>>;
+    usePropsContext: () => Record<string, any>;
+    useRecipeResult: (props: any) => {
+        styles: Record<string, SystemStyleObject>;
+        classNames: Record<string, string>;
+        props: {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        };
+    };
+    withProvider: <T, P>(Component: React.ElementType<any>, slot: R extends keyof ConfigRecipeSlots ? ConfigRecipeSlots[R] : string, options?: WithProviderOptions<P>) => React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<T>>;
+    withContext: <T, P_1>(Component: React.ElementType<any>, slot?: R extends keyof ConfigRecipeSlots ? ConfigRecipeSlots[R] : string, options?: WithContextOptions<P_1>) => React.ForwardRefExoticComponent<React.PropsWithoutRef<P_1> & React.RefAttributes<T>>;
+    withRootProvider: <P_2>(Component: React.ElementType<any>, options?: WithRootProviderOptions<P_2>) => React.FC<React.PropsWithoutRef<P_2>>;
+    useStyles: () => Record<string, SystemStyleObject>;
+    useClassNames: () => Record<string, string>;
+};
+export {};

package/dist/types/styled-system/css-var.d.ts

@@ -0,0 +1,9 @@
+export interface CssVar {
+    var: string;
+    ref: string;
+}
+export interface CssVarOptions {
+    fallback?: string | undefined;
+    prefix?: string | undefined;
+}
+export declare function cssVar(name: string, options?: CssVarOptions): CssVar;

package/dist/types/styled-system/css.d.ts

@@ -0,0 +1,9 @@
+import { type Dict } from "../utils";
+import type { SystemStyleObject } from "./css.types";
+import type { SystemContext } from "./types";
+type CssFnOptions = Pick<SystemContext, "conditions"> & {
+    normalize: (styles: Dict) => Dict;
+    transform: (prop: string, value: any) => Dict | undefined;
+};
+export declare function createCssFn(context: CssFnOptions): (...styleArgs: SystemStyleObject[]) => Dict;
+export {};

package/dist/types/styled-system/css.types.d.ts

@@ -0,0 +1,46 @@
+import type { PropertiesFallback } from "csstype";
+import type { Conditions } from "./generated/conditions.gen";
+import type { CssVarProperties, SystemProperties } from "./generated/system.gen";
+import type { AnySelector, Selectors } from "./selectors";
+type String = string & {};
+type Number = number & {};
+export type CssProperty = keyof PropertiesFallback;
+export interface CssProperties extends PropertiesFallback<String | Number>, CssVarProperties {
+}
+export interface CssKeyframes {
+    [name: string]: {
+        [time: string]: CssProperties;
+    };
+}
+export type KeyframeIdentityFn = (keyframes: CssKeyframes) => CssKeyframes;
+export type Condition = keyof Conditions;
+export type ConditionalValue<V> = V | Array<V | null> | {
+    [K in keyof Conditions]?: ConditionalValue<V>;
+};
+export type Nested<P> = P & {
+    [K in Selectors]?: Nested<P>;
+} & {
+    [K in AnySelector]?: Nested<P>;
+} & {
+    [K in keyof Conditions]?: Nested<P>;
+};
+export type MinimalNested<P> = {
+    [K in keyof Conditions]?: Nested<P>;
+};
+export type NestedCssProperties = Nested<CssProperties>;
+export type SystemStyleObject = Nested<SystemProperties & CssVarProperties>;
+export type SystemStyleIdentityFn = (style: SystemStyleObject) => SystemStyleObject;
+export interface GlobalStyleObject {
+    [selector: string]: SystemStyleObject;
+}
+export type GlobalStyleIdentityFn = (global: GlobalStyleObject) => GlobalStyleObject;
+type FilterStyleObject<P extends string> = {
+    [K in P]?: K extends keyof SystemStyleObject ? SystemStyleObject[K] : unknown;
+};
+export type CompositionStyleObject<Property extends string> = Nested<FilterStyleObject<Property> & CssVarProperties>;
+interface WithCss {
+    css?: SystemStyleObject | undefined;
+}
+type StyleProps = SystemProperties & MinimalNested<SystemStyleObject>;
+export type JsxStyleProps = StyleProps & WithCss;
+export {};

package/dist/types/styled-system/cva.d.ts

@@ -0,0 +1,11 @@
+import { type Dict } from "../utils";
+import type { RecipeCreatorFn } from "./recipe.types";
+import type { Condition, CssFn, Layers } from "./types";
+interface Options {
+    normalize: (styles: Dict) => Dict;
+    css: CssFn;
+    conditions: Condition;
+    layers: Layers;
+}
+export declare function createRecipeFn(options: Options): RecipeCreatorFn;
+export {};

package/dist/types/styled-system/display-name.d.ts

@@ -0,0 +1,11 @@
+import type { ElementType } from "react";
+/**
+ * `displayName` or `name` from a component type. For intrinsic string tags (e.g. `"div"`),
+ * returns `undefined` — those do not carry a component name.
+ */
+export declare function getElementTypeDisplayName(Component: ElementType): string | undefined;
+export declare function upperFirst(str: string): string;
+/** displayName for slot-recipe parts, e.g. `Accordion` + `root` → `AccordionRoot`. */
+export declare function inferSlotRecipeComponentDisplayName(contextName: string, slot: string): string;
+/** displayName for `withRootProvider` wrappers, e.g. `Dialog` + `Root` → `DialogRoot`. */
+export declare function inferRootProviderDisplayName(contextName: string, innerDisplayNameOrName: string | undefined): string | undefined;

package/dist/types/styled-system/empty.d.ts

@@ -0,0 +1,3 @@
+import type { SystemStyleObject } from "./css.types";
+export declare const EMPTY_STYLES: Readonly<SystemStyleObject>;
+export declare const EMPTY_SLOT_STYLES: Readonly<Record<string, SystemStyleObject>>;

package/dist/types/styled-system/esc.d.ts

@@ -0,0 +1 @@
+export declare const esc: (sel: string) => string;

package/dist/types/styled-system/expand-reference.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Recursively parse a string to extract Panda token references (curly or with the `token` function syntax)
+ * Allows nested token references, e.g. `token(colors.xxx.yyy, token(colors.aaa.bbb, blue))`
+ * Properly ignore CSS vars in fallback syntax, e.g. `token(colors.xxx.yyy, var(--some-var, var(--can-be-nested, blue)))`
+ */
+export declare const expandTokenReferences: (str: string, resolve: (path: string) => string | undefined) => string;

package/dist/types/styled-system/factory.d.ts

@@ -0,0 +1,2 @@
+import type { StyledFactoryFn } from "./factory.types";
+export declare const mainbase: StyledFactoryFn;

package/dist/types/styled-system/factory.types.d.ts

@@ -0,0 +1,52 @@
+import type { Assign } from "@ark-ui/react";
+import type { ComponentProps, ComponentPropsWithoutRef, ElementType, FunctionComponent, JSX } from "react";
+import type { Dict, DistributiveOmit, DistributiveUnion, Pretty } from "../utils";
+import type { MinimalNested, SystemStyleObject } from "./css.types";
+import type { SystemProperties } from "./generated/system.gen";
+import type { RecipeDefinition, RecipeSelection, RecipeVariantRecord } from "./recipe.types";
+export interface UnstyledProp {
+    /**
+     * If `true`, the element will opt out of the theme styles.
+     */
+    unstyled?: boolean | undefined;
+}
+export interface PolymorphicProps {
+    as?: ElementType | undefined;
+    asChild?: boolean | undefined;
+}
+export interface HtmlProps {
+    htmlSize?: number | undefined;
+    htmlWidth?: string | number | undefined;
+    htmlHeight?: string | number | undefined;
+    htmlTranslate?: "yes" | "no" | undefined;
+    htmlContent?: string | undefined;
+}
+export type HtmlProp = "color" | "size" | "translate" | "transition" | "width" | "height" | "content";
+export type PatchHtmlProps<T> = DistributiveOmit<T, HtmlProp> & HtmlProps;
+export type JsxHtmlProps<T extends Dict, P extends Dict = {}> = Assign<PatchHtmlProps<T>, P>;
+export type MainbaseComponent<T extends ElementType, P extends Dict = {}> = FunctionComponent<HTMLMainbaseProps<T, P> & {
+    ref?: any | undefined;
+}>;
+export type HTMLMainbaseProps<T extends ElementType, P extends Dict = {}> = JsxHtmlProps<ComponentPropsWithoutRef<T>, Assign<JsxStyleProps, P> & PolymorphicProps>;
+export type JsxElement<T extends ElementType, P extends Dict> = T extends MainbaseComponent<infer A, infer B> ? MainbaseComponent<A, Pretty<DistributiveUnion<P, B>>> : MainbaseComponent<T, P>;
+export interface JsxFactory {
+    <T extends ElementType>(component: T): MainbaseComponent<T, {}>;
+    <T extends ElementType, P extends RecipeVariantRecord>(component: T, recipe: RecipeDefinition<P>, options?: JsxFactoryOptions<Assign<ComponentProps<T>, RecipeSelection<P>>>): JsxElement<T, RecipeSelection<P>>;
+}
+type JsxElements = {
+    [K in keyof JSX.IntrinsicElements]: MainbaseComponent<K, {}>;
+};
+export type StyledFactoryFn = JsxFactory & JsxElements;
+export type DataAttr = Record<`data-${string}`, string | number | undefined | null | boolean>;
+export interface JsxFactoryOptions<TProps> {
+    forwardProps?: string[] | undefined;
+    defaultProps?: (Partial<TProps> & DataAttr) | undefined;
+    forwardAsChild?: boolean | undefined;
+    displayName?: string | undefined;
+    shouldForwardProp?(prop: string, variantKeys: string[]): boolean;
+}
+export interface JsxStyleProps extends SystemProperties, MinimalNested<SystemStyleObject> {
+    css?: SystemStyleObject | undefined | Omit<(SystemStyleObject | undefined)[], keyof any[]>;
+}
+export type InferRecipeProps<T> = T extends MainbaseComponent<any, infer P> ? P : {};
+export {};