import { MarkThemeType, ShapeType, SurfaceThemeType, ThemeType } from '../const/types.js';
/**
 * What a `ConfigProvider` says about everything under it. Form is deliberately absent: `Form`'s `size`,
 * `shape` and `theme` are documented as the appearance of its *child controls*, and a Card, Table or Alert
 * sitting inside a form is not one — inheriting there meant `<Form size="small">` shrank every panel around it.
 * Controls call `useFormAppearance` instead, which keeps the same three keys and layers Form on top.
 */
export declare function useConfigAppearance(): {
    size: import('../index.js').SizeType | undefined;
    shape: ShapeType | undefined;
    theme: ThemeType | undefined;
};
/** For the controls a `Form` wraps: what the form says, then what the provider says. */
export declare function useFormAppearance(): {
    size: import('../index.js').SizeType | undefined;
    shape: ShapeType | undefined;
    theme: ThemeType | undefined;
};
export declare function normalizeSurfaceShape(shape: ShapeType | undefined): "round" | "default" | "square" | undefined;
/**
 * Every component that paints tier classes resolves its value here instead of copying the comparison.
 * Writing no `theme` at all is how a caller says "listen to the component", and this returns the tier
 * that component was built to look like — the same class it reaches with no `theme`, so the two can
 * never drift. A component's own default differs (input-family is `fill`, `collapse` is `outline`,
 * `image` is `plain`), which is why the fallback is a parameter rather than a constant.
 */
export declare function resolveTheme(theme: ThemeType | undefined, fallback: ThemeType): ThemeType;
/**
 * The other shape of "listen to the component": some components own no tier class for their default
 * look at all. Button's `k-btn-default` is a *type* class, and a tier the stylesheet never paints —
 * `k-btn-underlined`, since an underline only means something on a control you type into — is a dead
 * class. An unguarded `` [`k-<component>-${theme}`]: theme `` ships both, so a component in this shape
 * resolves through here: a value outside the tiers it actually paints yields `undefined`, emits no tier
 * class, and leaves the component's own look in place.
 */
export declare function resolvePaintedTheme<T extends ThemeType>(theme: ThemeType | undefined, painted: readonly T[]): T | undefined;
/**
 * The two painted sets as values, for the components that hand a tier *onward* instead of painting it:
 * a group forwarding to its items, a dropdown forwarding to its buttons, a chip list forwarding to
 * `Tag`. Those callers must vouch for what they pass — `theme` is typed by what the receiver paints —
 * so they run the inherited value through the receiver's guard rather than forwarding a tier the
 * receiver would only fall back from. A component that paints its own surface keeps its own
 * `PAINTED_THEMES` list next to its stylesheet, because the style contract reads it from there.
 */
export declare const SURFACE_THEMES: readonly SurfaceThemeType[];
export declare const MARK_THEMES: readonly MarkThemeType[];