@bridge-ui/vue 0.0.0

package/dist/Components/Textarea/composables/useTextarea.js

@@ -0,0 +1,72 @@
+import { mergePartBind as e, useBridgeUIComponent as t, useBridgeUIMergedRegistryClasses as n } from "../../../Utils/index.js";
+import { useFormField as r } from "../../FormField/composables/useFormField.js";
+import { computed as i, onMounted as a, useAttrs as o, watch as s } from "vue";
+import { get as c, isNil as l, omit as u } from "es-toolkit/compat";
+import { adjustAutosizeTextareaHeight as d, cn as f, mergeBridgeUILayeredClasses as p } from "@bridge-ui/core";
+import { resizeProps as m } from "@bridge-ui/core/Components/Textarea";
+//#region src/Components/Textarea/composables/useTextarea.ts
+function h(h, g) {
+	let _ = o(), v = i(() => ({
+		resize: h.resize,
+		classes: h.classes,
+		autosize: h.autosize
+	})), { entry: y, merged: b } = t({
+		componentName: "Textarea",
+		props: () => v.value,
+		libDefaults: {
+			resize: "none",
+			autosize: !1
+		}
+	}), x = n({
+		entry: y,
+		props: () => v.value
+	}), S = i(() => !!h.likeInput), C = i(() => S.value ? h.autosize ?? !0 : !!b.value.autosize), w = i(() => {
+		let e = _.rows;
+		return S.value ? e ?? 1 : e;
+	}), T = r(() => ({
+		...u(_, ["rows"]),
+		...u(h, [
+			"autosize",
+			"resize",
+			"likeInput"
+		]),
+		classes: x.value
+	}), {
+		size: "md",
+		rounded: "md",
+		color: "primary",
+		variant: "outline",
+		withErrorIcon: !0
+	}, {
+		control: () => "textarea",
+		likeInput: () => S.value
+	}), E = i(() => C.value ? "none" : b.value.resize ?? "none"), D = i(() => c(p(m, y.value?.customProps?.resize), E.value ?? "none")), O = i(() => _.onInput), k = (e) => {
+		!e || !C.value || d(e);
+	}, A = (e) => {
+		k(e.target), O.value?.(e);
+	}, j = i(() => e(T.inputBind.value, {
+		...C.value ? { onInput: A } : {},
+		...l(w.value) ? {} : { rows: w.value }
+	}, f({
+		"flex-1 min-w-0": S.value,
+		"overflow-hidden": C.value,
+		"min-w-0 flex-none": !S.value,
+		[D.value ?? ""]: !0
+	})));
+	return s(() => [
+		C.value,
+		S.value,
+		g.value,
+		T.isStacked.value
+	], () => {
+		k(g.value);
+	}, { immediate: !0 }), a(() => {
+		k(g.value);
+	}), {
+		formField: T,
+		adjustHeight: k,
+		textareaBind: j
+	};
+}
+//#endregion
+export { h as useTextarea };

package/dist/Components/Textarea/index.d.ts

@@ -0,0 +1,3 @@
+export { useTextarea } from './composables/useTextarea';
+export type { TextareaClasses, TextareaCustomProps, TextareaOwnProps, TextareaProps, TextareaResizeOverrides, TextareaSlots, } from './textarea.types';
+export { default as Textarea } from './Textarea.vue';

package/dist/Components/Textarea/index.js

@@ -0,0 +1,3 @@
+import { useTextarea as e } from "./composables/useTextarea.js";
+import t from "./Textarea.js";
+export { t as Textarea, e as useTextarea };

package/dist/Components/Textarea/textarea.types.d.ts

@@ -0,0 +1,34 @@
+import { TextareaHTMLAttributes } from 'vue';
+import { MergeHtmlProps, MergeProps, TextareaResize } from '@bridge-ui/core';
+import { FormFieldClasses, FormFieldCustomProps, FormFieldOwnProps, FormFieldSlots } from '../FormField/formField.types';
+export interface TextareaResizeOverrides {}
+export interface TextareaClasses extends FormFieldClasses {}
+export interface TextareaCustomProps extends FormFieldCustomProps {}
+export interface TextareaOwnProps extends Omit<FormFieldOwnProps, "field"> {
+    /**
+     * Whether the textarea automatically resizes with its content.
+     *
+     * Defaults to `true` when `likeInput` is set; otherwise `false`.
+     */
+    autosize?: boolean;
+    /**
+     * Use compact TextField-like sizing instead of the default multiline textarea profile.
+     * Enables `autosize` and `rows={1}` by default; both can be overridden explicitly.
+     *
+     * @default false
+     */
+    likeInput?: boolean;
+    /**
+     * Native resize handle (`resize` CSS). Ignored when `autosize` is `true`.
+     *
+     * @default "none"
+     */
+    resize?: MergeProps<TextareaResize, TextareaResizeOverrides>;
+}
+export interface TextareaSlots extends FormFieldSlots {}
+export type TextareaProps = MergeHtmlProps<TextareaOwnProps, TextareaHTMLAttributes> & {
+    /**
+     * Bound with `v-model` on the component.
+     */
+    modelValue?: null | string;
+};

package/dist/Provider/BridgeUIProvider.js

@@ -0,0 +1,5 @@
+import e from "./BridgeUIProvider.vue_vue_type_script_setup_true_lang.js";
+//#region src/Provider/BridgeUIProvider.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/Provider/BridgeUIProvider.vue.d.ts

@@ -0,0 +1,18 @@
+import { BridgeUIComponentsConfig, BridgeUIGlobal } from '@bridge-ui/core';
+type __VLS_Props = {
+    components?: BridgeUIComponentsConfig;
+    global?: Partial<BridgeUIGlobal>;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Provider/BridgeUIProvider.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,20 @@
+import { BRIDGE_UI_INJECTION_KEY as e } from "./injectionKey.js";
+import { createBridgeUIApi as t } from "./createBridgeUIApi.js";
+import { computed as n, defineComponent as r, inject as i, provide as a, renderSlot as o } from "vue";
+//#region src/Provider/BridgeUIProvider.vue?vue&type=script&setup=true&lang.ts
+var s = /* @__PURE__ */ r({
+	__name: "BridgeUIProvider",
+	props: {
+		components: {},
+		global: {}
+	},
+	setup(r) {
+		let s = r;
+		return a(e, t(i(e, void 0), n(() => ({
+			global: s.global ?? {},
+			components: s.components ?? {}
+		})))), (e, t) => o(e.$slots, "default");
+	}
+});
+//#endregion
+export { s as default };

package/dist/Provider/bridgeUITypes.d.ts

@@ -0,0 +1,8 @@
+import { ComputedRef } from 'vue';
+import { BridgeUIComponentsConfig, BridgeUIGlobal } from '@bridge-ui/core';
+export interface BridgeUIContextApi {
+    components: ComputedRef<BridgeUIComponentsConfig>;
+    global: ComputedRef<BridgeUIGlobal>;
+    setComponents: (patch: BridgeUIComponentsConfig) => void;
+    setGlobal: (patch: Partial<BridgeUIGlobal>) => void;
+}

package/dist/Provider/createBridgeUI.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'vue';
+import { BridgeUIOptions } from '@bridge-ui/core';
+export declare function createBridgeUI(options?: BridgeUIOptions): Plugin;

package/dist/Provider/createBridgeUI.js

@@ -0,0 +1,15 @@
+import { BRIDGE_UI_INJECTION_KEY as e } from "./injectionKey.js";
+import { createBridgeUIApi as t } from "./createBridgeUIApi.js";
+import { computed as n } from "vue";
+//#region src/Provider/createBridgeUI.ts
+function r(r = {}) {
+	return { install(i) {
+		let a = t(void 0, n(() => ({
+			global: r.global ?? {},
+			components: r.components ?? {}
+		})));
+		i.provide(e, a);
+	} };
+}
+//#endregion
+export { r as createBridgeUI };

package/dist/Provider/createBridgeUIApi.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef } from 'vue';
+import { BridgeUIComponentsConfig, BridgeUIGlobal } from '@bridge-ui/core';
+import { BridgeUIContextApi } from './bridgeUITypes';
+export declare function createBridgeUIApi(parent: undefined | BridgeUIContextApi, optionsRef: ComputedRef<{
+    components: BridgeUIComponentsConfig;
+    global: Partial<BridgeUIGlobal>;
+}>): BridgeUIContextApi;

package/dist/Provider/createBridgeUIApi.js

@@ -0,0 +1,36 @@
+import { computed as e, shallowRef as t } from "vue";
+import { BRIDGE_UI_DEFAULT_GLOBAL as n, mergeBridgeUIComponents as r, mergeBridgeUIGlobal as i } from "@bridge-ui/core";
+import { toMerged as a } from "es-toolkit/object";
+//#region src/Provider/createBridgeUIApi.ts
+function o(o, s) {
+	let c = t({}), l = t({}), u = e(() => i({
+		partials: [s.value.global],
+		base: o ? o.global.value : n
+	})), d = e(() => i({
+		base: u.value,
+		partials: [c.value]
+	})), f = e(() => r({
+		partials: [s.value.components],
+		base: o ? o.components.value : {}
+	})), p = e(() => r({
+		base: f.value,
+		partials: [l.value]
+	}));
+	function m(e) {
+		c.value = a(c.value, e);
+	}
+	function h(e) {
+		l.value = r({
+			partials: [e],
+			base: l.value
+		});
+	}
+	return {
+		global: d,
+		setGlobal: m,
+		components: p,
+		setComponents: h
+	};
+}
+//#endregion
+export { o as createBridgeUIApi };

package/dist/Provider/index.d.ts

@@ -0,0 +1,5 @@
+import { default as BridgeUIProvider } from './BridgeUIProvider.vue';
+export type { BridgeUIContextApi } from './bridgeUITypes';
+export { createBridgeUI } from './createBridgeUI';
+export { useBridgeUI } from './useBridgeUI';
+export { BridgeUIProvider };

package/dist/Provider/index.js

@@ -0,0 +1,4 @@
+import { useBridgeUI as e } from "./useBridgeUI.js";
+import t from "./BridgeUIProvider.js";
+import { createBridgeUI as n } from "./createBridgeUI.js";
+export { t as BridgeUIProvider, n as createBridgeUI, e as useBridgeUI };

package/dist/Provider/injectionKey.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { BridgeUIContextApi } from './bridgeUITypes';
+export declare const BRIDGE_UI_INJECTION_KEY: InjectionKey<BridgeUIContextApi>;

package/dist/Provider/injectionKey.js

@@ -0,0 +1,4 @@
+//#region src/Provider/injectionKey.ts
+var e = Symbol.for("@bridge-ui/vue");
+//#endregion
+export { e as BRIDGE_UI_INJECTION_KEY };

package/dist/Provider/useBridgeUI.d.ts

@@ -0,0 +1,2 @@
+import { BridgeUIContextApi } from './bridgeUITypes';
+export declare function useBridgeUI(): null | BridgeUIContextApi;

package/dist/Provider/useBridgeUI.js

@@ -0,0 +1,8 @@
+import { BRIDGE_UI_INJECTION_KEY as e } from "./injectionKey.js";
+import { inject as t } from "vue";
+//#region src/Provider/useBridgeUI.ts
+function n() {
+	return t(e, null);
+}
+//#endregion
+export { n as useBridgeUI };

package/dist/Utils/index.d.ts

@@ -0,0 +1,47 @@
+import { ComponentPublicInstance, ComputedRef, MaybeRefOrGetter } from 'vue';
+import { FormFieldSize } from '@bridge-ui/core/Components/FormField';
+import { IconSize } from '@bridge-ui/core/Components/Icon';
+import { BridgeUIComponentsConfig } from '@bridge-ui/core/Config';
+import { useBridgeUI } from '../Provider/useBridgeUI';
+type RegistryEntryFor<K extends keyof BridgeUIComponentsConfig> = NonNullable<BridgeUIComponentsConfig[K]>;
+export type UseBridgeUIComponentReturn<P extends object, K extends keyof BridgeUIComponentsConfig> = {
+    bridge: ReturnType<typeof useBridgeUI>;
+    components: ComputedRef<null | BridgeUIComponentsConfig>;
+    entry: ComputedRef<undefined | RegistryEntryFor<K>>;
+    merged: ComputedRef<P>;
+};
+/**
+ * Defines a renderless component for unit tests (avoids Vue "missing template" warnings).
+ */
+export declare function defineHeadlessComponent(setup: () => void): import('vue').DefineComponent<{}, () => null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+/**
+ * Merges Vue-specific classes into the `class` attribute.
+ */
+export declare const mergePartBind: <Bridge extends object, Part extends object | undefined = undefined, Inherited extends object | undefined = undefined>(partProps: Part, inheritedAttrs: Inherited, bridgeProps: string | Bridge) => import('@bridge-ui/core').MergePartBind<Bridge, "class", Part, Inherited>;
+/**
+ * Registry entry + props merged with Bridge defaults for a named component.
+ */
+export declare function useBridgeUIComponent<P extends object, K extends keyof BridgeUIComponentsConfig>({ props, libDefaults, componentName, }: {
+    componentName: K;
+    libDefaults?: Partial<P>;
+    props: MaybeRefOrGetter<Partial<P>>;
+}): UseBridgeUIComponentReturn<P, K>;
+/**
+ * Merges `entry.classes` (Bridge provider) with `props.classes` (instance).
+ */
+export declare function useBridgeUIMergedRegistryClasses<C extends object>({ entry, props, }: {
+    entry: ComputedRef<undefined | {
+        classes?: object;
+    }>;
+    props: MaybeRefOrGetter<{
+        classes?: Partial<C>;
+    }>;
+}): ComputedRef<Partial<C>>;
+export declare function resolveFieldAdornmentIconSize(fieldSize?: keyof FormFieldSize): keyof IconSize;
+/**
+ * Resolves a Vue template ref callback value to an HTMLElement.
+ */
+export declare function resolveVnodeRefElement(element: null | Element | ComponentPublicInstance): null | HTMLElement;
+export { hasNamedSlot, hasSlotOrProp, isPropPresent, resolveNamedSlot, resolveSlotOrProp, } from './slotOrProp';
+export { useHoldRepeat } from './useHoldRepeat';
+export type { HoldRepeatAction, UseHoldRepeatOptions, } from './useHoldRepeat';

package/dist/Utils/index.js

@@ -0,0 +1,55 @@
+import { useBridgeUI as e } from "../Provider/useBridgeUI.js";
+import { hasNamedSlot as t, hasSlotOrProp as n, isPropPresent as r, resolveNamedSlot as i, resolveSlotOrProp as a } from "./slotOrProp.js";
+import { useHoldRepeat as o } from "./useHoldRepeat.js";
+import { computed as s, defineComponent as c, toValue as l, unref as u } from "vue";
+import { get as d, isNil as f } from "es-toolkit/compat";
+import { createMergePartBind as p } from "@bridge-ui/core";
+import { mergeBridgeUILayeredClasses as m, mergePropsWithBridgeUIDefaults as h } from "@bridge-ui/core/Utils";
+//#region src/Utils/index.ts
+function g(e) {
+	return c({
+		name: "HeadlessTestComponent",
+		setup() {
+			return e(), () => null;
+		}
+	});
+}
+var _ = p("class");
+function v({ props: t, libDefaults: n, componentName: r }) {
+	let i = e(), a = s(() => f(i) ? null : u(i.components));
+	return {
+		entry: s(() => d(a.value, r)),
+		bridge: i,
+		merged: s(() => h({
+			libDefaults: n,
+			componentName: r,
+			props: l(t),
+			components: a.value
+		})),
+		components: a
+	};
+}
+function y({ entry: e, props: t }) {
+	return s(() => m(d(e.value, "classes"), l(t).classes));
+}
+function b(e) {
+	return d({
+		xs: "xs",
+		sm: "sm",
+		md: "md",
+		lg: "md",
+		xl: "lg",
+		"2xs": "xs",
+		"2xl": "lg"
+	}, e ?? "md");
+}
+function x(e) {
+	if (e instanceof HTMLElement) return e;
+	if (e && "$el" in e) {
+		let t = e.$el;
+		return t instanceof HTMLElement ? t : null;
+	}
+	return null;
+}
+//#endregion
+export { g as defineHeadlessComponent, t as hasNamedSlot, n as hasSlotOrProp, r as isPropPresent, _ as mergePartBind, b as resolveFieldAdornmentIconSize, i as resolveNamedSlot, a as resolveSlotOrProp, x as resolveVnodeRefElement, v as useBridgeUIComponent, y as useBridgeUIMergedRegistryClasses, o as useHoldRepeat };

package/dist/Utils/slotOrProp.d.ts

@@ -0,0 +1,28 @@
+import { Slot, Slots, VNodeChild } from 'vue';
+type VueSlots = Slots | undefined | Readonly<Slots>;
+/**
+ * Whether a prop value is considered present for fallback rendering.
+ */
+export declare function isPropPresent(value: unknown): boolean;
+/**
+ * Whether a named slot was passed to the component.
+ */
+export declare function hasNamedSlot(slots: VueSlots, name: string): boolean;
+/**
+ * Whether a named slot or a fallback prop should render (slot wins when both exist).
+ */
+export declare function hasSlotOrProp(slots: VueSlots, name: string, prop: unknown): boolean;
+/**
+ * Slot render function for `<component :is="resolveNamedSlot(slots, name)" />`.
+ * Returns the slot function itself so `:is` keeps a stable identity across parent
+ * re-renders (wrapping in a new render function would remount slot content and drop
+ * native states such as `:hover` / `:active` during hold-repeat).
+ */
+export declare function resolveNamedSlot(slots: VueSlots, name: string): Slot | undefined;
+/**
+ * Render target for `<component :is="resolveSlotOrProp(slots, name, fallback)" />`.
+ * Returns the named slot function when present; otherwise a render function for the
+ * fallback prop.
+ */
+export declare function resolveSlotOrProp(slots: VueSlots, name: string, fallback?: null | number | string): Slot | (() => null | VNodeChild);
+export type { Slot };

package/dist/Utils/slotOrProp.js

@@ -0,0 +1,23 @@
+import { get as e, isEmpty as t, isNil as n, isString as r } from "es-toolkit/compat";
+//#region src/Utils/slotOrProp.ts
+function i(e) {
+	return n(e) ? !1 : r(e) ? !t(e) : !0;
+}
+function a(t, r) {
+	return !n(e(t, r));
+}
+function o(e, t, n) {
+	return a(e, t) || i(n);
+}
+function s(t, n) {
+	return e(t, n);
+}
+function c(t, r, a) {
+	let o = e(t, r);
+	if (!n(o)) return o;
+	if (!i(a)) return () => null;
+	let s = String(a);
+	return () => s;
+}
+//#endregion
+export { a as hasNamedSlot, o as hasSlotOrProp, i as isPropPresent, s as resolveNamedSlot, c as resolveSlotOrProp };

package/dist/Utils/useHoldRepeat.d.ts

@@ -0,0 +1,13 @@
+import { MaybeRefOrGetter } from 'vue';
+export type HoldRepeatAction = () => void | boolean;
+export type UseHoldRepeatOptions = {
+    disabled?: boolean;
+    initialDelayMs?: number;
+    intervalMs?: number;
+};
+export declare function useHoldRepeat(action: HoldRepeatAction, options?: MaybeRefOrGetter<UseHoldRepeatOptions>): {
+    onPressClick: () => void;
+    onPressPointerUp: (event: PointerEvent) => void;
+    onPressPointerDown: (event: PointerEvent) => void;
+    onPressLostPointerCapture: () => void;
+};

package/dist/Utils/useHoldRepeat.js

@@ -0,0 +1,38 @@
+import { onBeforeUnmount as e, toValue as t } from "vue";
+import { isNil as n } from "es-toolkit/compat";
+//#region src/Utils/useHoldRepeat.ts
+var r = 75, i = 400;
+function a(a, o) {
+	let s = !1, c, l, u = () => {
+		n(c) || (clearTimeout(c), c = void 0), n(l) || (clearInterval(l), l = void 0);
+	}, d = () => {
+		a() === !1 && u();
+	}, f = () => {
+		u(), d();
+		let { intervalMs: e, initialDelayMs: n } = t(o) ?? {};
+		c = setTimeout(() => {
+			l = setInterval(d, e ?? r);
+		}, n ?? i);
+	};
+	return e(u), {
+		onPressClick: () => {
+			if (s) {
+				s = !1;
+				return;
+			}
+			t(o)?.disabled || d();
+		},
+		onPressPointerUp: (e) => {
+			let t = e.currentTarget;
+			t.hasPointerCapture(e.pointerId) && t.releasePointerCapture(e.pointerId), u();
+		},
+		onPressPointerDown: (e) => {
+			t(o)?.disabled || e.button === 0 && (s = !0, e.currentTarget.setPointerCapture(e.pointerId), f());
+		},
+		onPressLostPointerCapture: () => {
+			u();
+		}
+	};
+}
+//#endregion
+export { a as useHoldRepeat };

package/dist/augments.d.ts

@@ -0,0 +1,113 @@
+import { AlertClasses, AlertProps } from './Components/Alert';
+import { AvatarClasses, AvatarProps } from './Components/Avatar';
+import { BadgeClasses, BadgeProps } from './Components/Badge';
+import { ButtonClasses, ButtonProps } from './Components/Button';
+import { CardClasses, CardProps } from './Components/Card';
+import { CheckboxClasses, CheckboxProps } from './Components/Checkbox';
+import { FormControlClasses, FormControlProps } from './Components/FormControl';
+import { FormFieldClasses, FormFieldProps } from './Components/FormField';
+import { IconProps } from './Components/Icon';
+import { LabelClasses, LabelProps } from './Components/Label';
+import { LinkClasses, LinkProps } from './Components/Link';
+import { ListClasses, ListProps } from './Components/List';
+import { ListItemClasses, ListItemProps } from './Components/ListItem';
+import { ListSectionClasses } from './Components/ListSection';
+import { MenuClasses, MenuProps } from './Components/Menu';
+import { ModalClasses, ModalProps } from './Components/Modal';
+import { NumberFieldClasses } from './Components/NumberField';
+import { PasswordFieldClasses } from './Components/PasswordField';
+import { RadioClasses, RadioProps } from './Components/Radio';
+import { SelectClasses, SelectProps } from './Components/Select';
+import { SnackbarClasses, SnackbarProps } from './Components/Snackbar';
+import { SwitchClasses, SwitchProps } from './Components/Switch';
+import { TextareaClasses, TextareaProps } from './Components/Textarea';
+declare module "@bridge-ui/core" {
+    interface AlertConfigOverrides {
+        classes: AlertClasses;
+        defaultProps: Partial<Pick<AlertProps, "color" | "shadow" | "padding" | "rounded" | "variant">>;
+    }
+    interface AvatarConfigOverrides {
+        classes: AvatarClasses;
+        defaultProps: Partial<Pick<AvatarProps, "size" | "color" | "rounded">>;
+    }
+    interface BadgeConfigOverrides {
+        classes: BadgeClasses;
+        defaultProps: Partial<Pick<BadgeProps, "size" | "color" | "density" | "rounded" | "variant">>;
+    }
+    interface ButtonConfigOverrides {
+        classes: ButtonClasses;
+        defaultProps: Partial<Pick<ButtonProps, "size" | "color" | "density" | "rounded" | "variant">>;
+    }
+    interface CardConfigOverrides {
+        classes: CardClasses;
+        defaultProps: Partial<Pick<CardProps, "shadow" | "padding" | "rounded" | "variant">>;
+    }
+    interface CheckboxConfigOverrides {
+        classes: CheckboxClasses;
+        defaultProps: Partial<Pick<CheckboxProps, "size" | "color" | "rounded">>;
+    }
+    interface FormControlConfigOverrides {
+        classes: FormControlClasses;
+        defaultProps: Partial<Pick<FormControlProps, "size" | "error" | "withoutErrorMessage">>;
+    }
+    interface FormFieldConfigOverrides {
+        classes: FormFieldClasses;
+        defaultProps: Partial<Pick<FormFieldProps, "size" | "color" | "rounded" | "variant" | "errorIcon" | "withErrorIcon">>;
+    }
+    interface IconConfigOverrides {
+        defaultProps: Partial<Pick<IconProps, "size">>;
+    }
+    interface LabelConfigOverrides {
+        classes: LabelClasses;
+        defaultProps: Partial<Pick<LabelProps, "size" | "required">>;
+    }
+    interface LinkConfigOverrides {
+        classes: LinkClasses;
+        defaultProps: Partial<Pick<LinkProps, "size" | "color" | "underline">>;
+    }
+    interface ListConfigOverrides {
+        classes: ListClasses;
+        defaultProps: Partial<Pick<ListProps, "padding">>;
+    }
+    interface ListItemConfigOverrides {
+        classes: ListItemClasses;
+        defaultProps: Partial<Pick<ListItemProps, "role" | "align">>;
+    }
+    interface ListSectionConfigOverrides {
+        classes: ListSectionClasses;
+    }
+    interface MenuConfigOverrides {
+        classes: MenuClasses;
+        defaultProps: Partial<Pick<MenuProps, "shadow" | "rounded">>;
+    }
+    interface ModalConfigOverrides {
+        classes: ModalClasses;
+        defaultProps: Partial<Pick<ModalProps, "blur" | "size" | "align" | "teleportTo" | "transition">>;
+    }
+    interface NumberFieldConfigOverrides {
+        classes: NumberFieldClasses;
+    }
+    interface PasswordFieldConfigOverrides {
+        classes: PasswordFieldClasses;
+    }
+    interface RadioConfigOverrides {
+        classes: RadioClasses;
+        defaultProps: Partial<Pick<RadioProps, "size" | "color" | "rounded">>;
+    }
+    interface SnackbarConfigOverrides {
+        classes: SnackbarClasses;
+        defaultProps: Partial<Pick<SnackbarProps, "color" | "padding" | "rounded" | "duration" | "position" | "teleportTo" | "transition" | "closeButton" | "progressbar">>;
+    }
+    interface SelectConfigOverrides {
+        classes: SelectClasses;
+        defaultProps: Partial<Pick<SelectProps, "size" | "color" | "rounded" | "variant">>;
+    }
+    interface SwitchConfigOverrides {
+        classes: SwitchClasses;
+        defaultProps: Partial<Pick<SwitchProps, "size" | "color" | "rounded">>;
+    }
+    interface TextareaConfigOverrides {
+        classes: TextareaClasses;
+        defaultProps: Partial<Pick<TextareaProps, "resize" | "autosize">>;
+    }
+}