@equal-experts/kuat-react 0.13.0 → 0.14.0-beta.0

package/dist/components/ui/carousel/carousel.d.ts

@@ -0,0 +1,50 @@
+import { default as useEmblaCarousel, UseEmblaCarouselType } from 'embla-carousel-react';
+import * as React from "react";
+type CarouselApi = UseEmblaCarouselType[1];
+type CarouselOptions = UseEmblaCarouselType[0];
+type CarouselPlugins = Parameters<typeof useEmblaCarousel>[1];
+type CarouselOrientation = "horizontal" | "vertical";
+export type CarouselItemBasis = 1 | 2 | 3;
+export type CarouselResponsiveBasis = Partial<Record<"sm" | "md" | "lg" | "xl" | "2xl", CarouselItemBasis>>;
+export type CarouselEventHandler = (api: CarouselApi, eventName: string) => void;
+export type CarouselEventHandlers = Partial<Record<string, CarouselEventHandler>>;
+interface CarouselContextValue {
+    api: CarouselApi;
+    basis: CarouselItemBasis;
+    responsiveBasis: CarouselResponsiveBasis;
+    orientation: CarouselOrientation;
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+}
+declare function useCarousel(): CarouselContextValue;
+export interface CarouselProps extends React.HTMLAttributes<HTMLDivElement> {
+    opts?: CarouselOptions;
+    basis?: CarouselItemBasis;
+    basisSm?: CarouselItemBasis;
+    basisMd?: CarouselItemBasis;
+    basisLg?: CarouselItemBasis;
+    basisXl?: CarouselItemBasis;
+    basis2xl?: CarouselItemBasis;
+    orientation?: CarouselOrientation;
+    plugins?: CarouselPlugins;
+    setApi?: (api: CarouselApi) => void;
+    events?: CarouselEventHandlers;
+}
+declare const Carousel: React.ForwardRefExoticComponent<CarouselProps & React.RefAttributes<HTMLDivElement>>;
+export interface CarouselContentProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+declare const CarouselContent: React.ForwardRefExoticComponent<CarouselContentProps & React.RefAttributes<HTMLDivElement>>;
+export interface CarouselItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    basis?: CarouselItemBasis;
+    basisSm?: CarouselItemBasis;
+    basisMd?: CarouselItemBasis;
+    basisLg?: CarouselItemBasis;
+    basisXl?: CarouselItemBasis;
+    basis2xl?: CarouselItemBasis;
+}
+declare const CarouselItem: React.ForwardRefExoticComponent<CarouselItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const CarouselPrevious: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const CarouselNext: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, useCarousel };

package/dist/components/ui/carousel/index.d.ts

@@ -0,0 +1,2 @@
+export { Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, useCarousel, } from './carousel';
+export type { CarouselItemBasis, CarouselResponsiveBasis, CarouselEventHandler, CarouselEventHandlers, CarouselProps, CarouselContentProps, CarouselItemProps, } from './carousel';

package/dist/components/ui/checkbox/checkbox-field.d.ts

@@ -0,0 +1,23 @@
+import { Checkbox } from './checkbox';
+import * as React from "react";
+export declare const CHECKBOX_FIELD_APPEARANCES: readonly ["plain", "card"];
+export type CheckboxFieldAppearance = (typeof CHECKBOX_FIELD_APPEARANCES)[number];
+export declare const CHECKBOX_FIELD_LAYOUTS: readonly ["inline", "block"];
+export type CheckboxFieldLayout = (typeof CHECKBOX_FIELD_LAYOUTS)[number];
+/** @deprecated Prefer composing `Field` + `Checkbox` for new form layouts. */
+export interface CheckboxFieldProps extends Omit<React.ComponentPropsWithoutRef<typeof Checkbox>, "id" | "children"> {
+    /** Primary label (always shown). */
+    label: React.ReactNode;
+    /** Optional secondary line (12px muted); works for both plain and card. */
+    secondaryText?: React.ReactNode;
+    /** `plain` — no border/padding; `card` — bordered padded container (Figma Rich). */
+    appearance?: CheckboxFieldAppearance;
+    /** `inline` — compact label; `block` — label row can grow (Figma Checkbox Group). */
+    layout?: CheckboxFieldLayout;
+    /** Place checkbox on the right of the text block. */
+    flipped?: boolean;
+    id?: string;
+}
+/** @deprecated Prefer composing `Field` + `Checkbox` for new form layouts. */
+declare const CheckboxField: React.ForwardRefExoticComponent<CheckboxFieldProps & React.RefAttributes<HTMLButtonElement>>;
+export { CheckboxField };

package/dist/components/ui/checkbox/checkbox.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export type CheckboxProps = React.ComponentPropsWithoutRef<typeof Checkbox>;
+export { Checkbox };

package/dist/components/ui/checkbox/index.d.ts

@@ -0,0 +1,4 @@
+export { Checkbox } from './checkbox';
+export type { CheckboxProps } from './checkbox';
+export { CheckboxField, CHECKBOX_FIELD_APPEARANCES, CHECKBOX_FIELD_LAYOUTS, } from './checkbox-field';
+export type { CheckboxFieldAppearance, CheckboxFieldLayout, CheckboxFieldProps, } from './checkbox-field';

package/dist/components/ui/content-card/content-card.d.ts

@@ -0,0 +1,29 @@
+import { KuatSlotContent } from '../../../lib/react-node-compat';
+import * as React from "react";
+export interface ContentCardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "content" | "children" | "title"> {
+    className?: string;
+    asChild?: boolean;
+    /** Optional media; when `null`, the media area is removed (no gap). */
+    imageSrc?: string | null;
+    imageAlt?: string;
+    /** Header props (not slots). */
+    badge: KuatSlotContent;
+    category: KuatSlotContent;
+    title: KuatSlotContent;
+    titleHeadingLevel: 1 | 2 | 3 | 4 | 5 | 6;
+    /** Optional basic content text (hidden when omitted). */
+    contentText?: string | null;
+    /** Header Accessory slot (flex row). */
+    headerAccessory?: KuatSlotContent | null;
+    /** Custom content slot below basic content. */
+    customContent?: KuatSlotContent | null;
+    /** Footer slot. */
+    footer?: KuatSlotContent | null;
+    children?: KuatSlotContent;
+    /** Width behavior for the root card container. */
+    width?: "default" | "fluid" | "custom";
+    /** Used when `width` is `custom`; accepts CSS max-width values. */
+    maxWidth?: React.CSSProperties["maxWidth"];
+}
+declare const ContentCard: React.ForwardRefExoticComponent<ContentCardProps & React.RefAttributes<HTMLDivElement>>;
+export { ContentCard };

package/dist/components/ui/content-card/index.d.ts

@@ -0,0 +1,2 @@
+export { ContentCard } from './content-card';
+export type { ContentCardProps } from './content-card';

package/dist/components/ui/dropdown-menu/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/components/ui/dropdown-menu/index.d.ts

@@ -0,0 +1 @@
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, } from './dropdown-menu';

package/dist/components/ui/ee-logo-icon/ee-logo-icon.d.ts

@@ -0,0 +1,11 @@
+
+/**
+ * Equal Experts logo icon (bracket mark only, no wordmark).
+ * Extracted from full EE logo; used in dark Service logo lockup.
+ * Source: https://github.com/EqualExperts/brand-assets
+ */
+export interface EELogoIconProps {
+    className?: string;
+}
+declare function EELogoIcon({ className }: EELogoIconProps): import("react/jsx-runtime").JSX.Element;
+export { EELogoIcon };

package/dist/components/ui/ee-logo-icon/index.d.ts

@@ -0,0 +1,2 @@
+export { EELogoIcon } from './ee-logo-icon';
+export type { EELogoIconProps } from './ee-logo-icon';

package/dist/components/ui/field/field.d.ts

@@ -0,0 +1,28 @@
+import * as React from "react";
+export declare const FIELD_ORIENTATIONS: readonly ["responsive", "vertical", "horizontal"];
+export type FieldOrientation = (typeof FIELD_ORIENTATIONS)[number];
+export interface FieldProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: FieldOrientation;
+}
+declare const Field: React.ForwardRefExoticComponent<FieldProps & React.RefAttributes<HTMLDivElement>>;
+declare const FieldSet: React.ForwardRefExoticComponent<React.FieldsetHTMLAttributes<HTMLFieldSetElement> & React.RefAttributes<HTMLFieldSetElement>>;
+export type FieldLegendVariant = "legend" | "label";
+export interface FieldLegendProps extends React.HTMLAttributes<HTMLLegendElement> {
+    variant?: FieldLegendVariant;
+}
+declare const FieldLegend: React.ForwardRefExoticComponent<FieldLegendProps & React.RefAttributes<HTMLLegendElement>>;
+declare const FieldGroup: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FieldLabel: React.ForwardRefExoticComponent<React.LabelHTMLAttributes<HTMLLabelElement> & React.RefAttributes<HTMLLabelElement>>;
+declare const FieldContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FieldTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const FieldDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const FieldSeparator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+type FieldIssue = {
+    message?: string;
+};
+export interface FieldErrorProps extends React.HTMLAttributes<HTMLDivElement> {
+    errors?: Array<FieldIssue | undefined> | FieldIssue;
+    issues?: Array<FieldIssue | undefined>;
+}
+declare const FieldError: React.ForwardRefExoticComponent<FieldErrorProps & React.RefAttributes<HTMLDivElement>>;
+export { Field, FieldContent, FieldDescription, FieldError, FieldGroup, FieldLabel, FieldLegend, FieldSeparator, FieldSet, FieldTitle, };

package/dist/components/ui/field/index.d.ts

@@ -0,0 +1,2 @@
+export { Field, FieldContent, FieldDescription, FieldError, FieldGroup, FieldLabel, FieldLegend, FieldSeparator, FieldSet, FieldTitle, FIELD_ORIENTATIONS, } from './field';
+export type { FieldErrorProps, FieldLegendProps, FieldLegendVariant, FieldOrientation, FieldProps, } from './field';

package/dist/components/ui/icon-button/icon-button.d.ts

@@ -0,0 +1,27 @@
+import { ButtonColor, ButtonVariant } from '../button/button';
+import * as React from "react";
+/** @deprecated Use "primary" instead. */
+export declare const ICON_BUTTON_VARIANT_DEFAULT_ALIAS = "default";
+export declare const ICON_BUTTON_SIZES: readonly ["mini", "small", "regular", "large"];
+/** @deprecated Use "small" instead. */
+export declare const ICON_BUTTON_SIZE_SM_ALIAS = "sm";
+/** @deprecated Use "large" instead. */
+export declare const ICON_BUTTON_SIZE_LG_ALIAS = "lg";
+export declare const ICON_BUTTON_ROUNDNESS: readonly ["default", "round"];
+export type IconButtonSize = (typeof ICON_BUTTON_SIZES)[number];
+export type IconButtonRoundness = (typeof ICON_BUTTON_ROUNDNESS)[number];
+export interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant | typeof ICON_BUTTON_VARIANT_DEFAULT_ALIAS;
+    size?: IconButtonSize | typeof ICON_BUTTON_SIZE_SM_ALIAS | typeof ICON_BUTTON_SIZE_LG_ALIAS;
+    color?: ButtonColor;
+    roundness?: IconButtonRoundness;
+    asChild?: boolean;
+}
+declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare function iconButtonVariants(options?: {
+    variant?: IconButtonProps["variant"];
+    size?: IconButtonProps["size"];
+    color?: ButtonColor;
+    roundness?: IconButtonRoundness;
+}): string;
+export { IconButton, iconButtonVariants };

package/dist/components/ui/icon-button/index.d.ts

@@ -0,0 +1,2 @@
+export { IconButton, iconButtonVariants, ICON_BUTTON_SIZES, ICON_BUTTON_ROUNDNESS, ICON_BUTTON_VARIANT_DEFAULT_ALIAS, ICON_BUTTON_SIZE_SM_ALIAS, ICON_BUTTON_SIZE_LG_ALIAS, } from './icon-button';
+export type { IconButtonProps, IconButtonSize, IconButtonRoundness, } from './icon-button';

package/dist/components/ui/input/index.d.ts

@@ -0,0 +1,2 @@
+export { Input, INPUT_SIZES } from './input';
+export type { InputProps, InputSize } from './input';

package/dist/components/ui/input/input.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+export declare const INPUT_SIZES: readonly ["regular", "large", "small", "mini"];
+export type InputSize = (typeof INPUT_SIZES)[number];
+/**
+ * Shared props for the Kuat `Input` wrapper + native field.
+ *
+ * For `type="file"`, avoid treating the control like a text field: browsers restrict the
+ * `value`, and React controlled file inputs are unusual—prefer an uncontrolled input with
+ * `ref` and `onChange` (see [shadcn file example](https://ui.shadcn.com/docs/components/radix/input#file)).
+ */
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    /** Visual size; maps to `input--size-*` (not the HTML `size` attribute). */
+    size?: InputSize;
+    /** Optional content before the field (icon, text, checkbox, etc.). */
+    leftDecoration?: React.ReactNode;
+    /** Optional content after the field (suffix text, button, icon, etc.). */
+    rightDecoration?: React.ReactNode;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/components/ui/kuat-carousel/index.d.ts

@@ -0,0 +1,2 @@
+export { KuatCarousel, KuatCarouselContent, KuatCarouselItem, KuatCarouselPrevious, KuatCarouselNext, useKuatCarousel, } from './kuat-carousel';
+export type { KuatCarouselSlidesPerView, KuatCarouselProps, KuatCarouselContentProps, KuatCarouselItemProps, } from './kuat-carousel';

package/dist/components/ui/kuat-carousel/kuat-carousel.d.ts

@@ -0,0 +1,16 @@
+import { useCarousel, CarouselEventHandler, CarouselEventHandlers, CarouselContentProps, CarouselItemProps, CarouselProps, CarouselItemBasis } from '../carousel';
+import * as React from "react";
+export type KuatCarouselSlidesPerView = CarouselItemBasis;
+export interface KuatCarouselProps extends Omit<CarouselProps, "basis"> {
+    slidesPerView?: KuatCarouselSlidesPerView;
+}
+declare const KuatCarousel: React.ForwardRefExoticComponent<KuatCarouselProps & React.RefAttributes<HTMLDivElement>>;
+type KuatCarouselContentProps = CarouselContentProps;
+type KuatCarouselItemProps = CarouselItemProps;
+declare const KuatCarouselContent: React.ForwardRefExoticComponent<CarouselContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const KuatCarouselItem: React.ForwardRefExoticComponent<CarouselItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const KuatCarouselPrevious: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const KuatCarouselNext: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const useKuatCarousel: typeof useCarousel;
+export type { KuatCarouselContentProps, KuatCarouselItemProps, CarouselEventHandler, CarouselEventHandlers };
+export { KuatCarousel, KuatCarouselContent, KuatCarouselItem, KuatCarouselPrevious, KuatCarouselNext, useKuatCarousel, };

package/dist/components/ui/kuat-header/index.d.ts

@@ -0,0 +1,4 @@
+export { KuatHeader, EELogo, kuatHeaderVariants, } from './kuat-header';
+export { KUAT_HEADER_VARIANTS, KUAT_HEADER_LOCKUP_VARIANTS, KUAT_HEADER_APP_SWITCHER_EMPTY, EE_LOGO_TEXT_COLORS, } from './kuat-header.types';
+export type { KuatHeaderProps, EELogoProps, KuatHeaderVariant, KuatHeaderLockupVariant, EELogoTextColor, KuatHeaderSubItem, KuatHeaderNavItem, KuatHeaderAccountItem, KuatHeaderAccountConfig, KuatHeaderAccountLabels, KuatHeaderAccountMobileTier, KuatHeaderActionItem, KuatHeaderApp, KuatHeaderAppSwitcherConfig, KuatHeaderAppSwitcherEmpty, KuatHeaderAppSwitcherLabels, KuatHeaderLockupConfig, } from './kuat-header.types';
+export { shouldShowAppSwitcher, resolveAppSwitcherLabels, resolveHeaderLockup, resolveAccountLabels, shouldShowAccountMobileTier, hasStructuredAccount, resolveDesktopAccountMenuItems, shouldUseDesktopAccountDropdown, } from './kuat-header.logic';

package/dist/components/ui/kuat-header/kuat-header.d.ts

@@ -0,0 +1,16 @@
+import { EELogoProps, KuatHeaderProps, KuatHeaderVariant } from './kuat-header.types';
+import * as React from "react";
+export type { EELogoProps, EELogoTextColor, KuatHeaderAccountConfig, KuatHeaderAccountItem, KuatHeaderAccountLabels, KuatHeaderAccountMobileTier, KuatHeaderActionItem, KuatHeaderApp, KuatHeaderAppSwitcherConfig, KuatHeaderAppSwitcherEmpty, KuatHeaderAppSwitcherLabels, KuatHeaderLockupConfig, KuatHeaderLockupVariant, KuatHeaderNavItem, KuatHeaderProps, KuatHeaderSubItem, KuatHeaderVariant, } from './kuat-header.types';
+export { KUAT_HEADER_VARIANTS, KUAT_HEADER_LOCKUP_VARIANTS, EE_LOGO_TEXT_COLORS, KUAT_HEADER_APP_SWITCHER_EMPTY, } from './kuat-header.types';
+export { shouldShowAppSwitcher, resolveAppSwitcherLabels, resolveHeaderLockup, } from './kuat-header.logic';
+/**
+ * Equal Experts Logo component
+ * Source: https://github.com/EqualExperts/brand-assets/blob/main/logo/logo-colour.svg
+ */
+declare function EELogo({ className, textColor }: EELogoProps): import("react/jsx-runtime").JSX.Element;
+declare const KuatHeader: React.ForwardRefExoticComponent<KuatHeaderProps & React.RefAttributes<HTMLElement>>;
+/** Returns class string for header variant (backward compatibility). */
+export declare function kuatHeaderVariants(options?: {
+    variant?: KuatHeaderVariant;
+}): string;
+export { KuatHeader, EELogo };

package/dist/components/ui/kuat-header/kuat-header.logic.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+import { KuatHeaderAccountConfig, KuatHeaderAppSwitcherConfig, KuatHeaderAppSwitcherLabels, KuatHeaderLockupConfig, KuatHeaderLockupVariant, KuatHeaderSubItem } from './kuat-header.types';
+
+export declare function shouldShowAppSwitcher(config?: KuatHeaderAppSwitcherConfig): boolean;
+export declare function resolveAppSwitcherLabels(config?: KuatHeaderAppSwitcherConfig): Required<KuatHeaderAppSwitcherLabels>;
+export declare function resolveAppSwitcherEmptyMessage(config?: KuatHeaderAppSwitcherConfig): string;
+export declare function shouldShowAccountMobileTier(account?: KuatHeaderAccountConfig): boolean;
+export declare function hasStructuredAccount(account?: KuatHeaderAccountConfig): boolean;
+/** Menu rows for the desktop account dropdown (from `account.mobile.items`). */
+export declare function resolveDesktopAccountMenuItems(account?: KuatHeaderAccountConfig): KuatHeaderSubItem[];
+/** Single primary row + mobile menu items → desktop shows a dropdown, not a direct link. */
+export declare function shouldUseDesktopAccountDropdown(account?: KuatHeaderAccountConfig): boolean;
+export declare function resolveAccountLabels(account?: KuatHeaderAccountConfig): {
+    teaserTitle: string;
+    teaserDescription: string;
+    nav: string;
+    title: string;
+};
+export type HeaderLockupMode = "hidden" | "custom" | "builtin";
+export declare function resolveHeaderLockup(options: {
+    logo?: ReactNode | null;
+    lockup?: KuatHeaderLockupConfig;
+}): {
+    mode: HeaderLockupMode;
+    lockupVariant: KuatHeaderLockupVariant;
+};
+export declare function resolveMobileSheetAriaLabel(options: {
+    mobileMenuAriaLabel?: string;
+    showAppSwitcher: boolean;
+    hasStructuredNavigation: boolean;
+    hasAccountMobileTier: boolean;
+}): string;

package/dist/components/ui/kuat-header/kuat-header.types.d.ts

@@ -0,0 +1,91 @@
+import type * as React from "react";
+export declare const KUAT_HEADER_VARIANTS: readonly ["default", "bold"];
+export type KuatHeaderVariant = (typeof KUAT_HEADER_VARIANTS)[number];
+export declare const KUAT_HEADER_LOCKUP_VARIANTS: readonly ["default", "demo"];
+export type KuatHeaderLockupVariant = (typeof KUAT_HEADER_LOCKUP_VARIANTS)[number];
+export declare const EE_LOGO_TEXT_COLORS: readonly ["grey", "white"];
+export type EELogoTextColor = (typeof EE_LOGO_TEXT_COLORS)[number];
+export declare const KUAT_HEADER_APP_SWITCHER_EMPTY: readonly ["hide", "message"];
+export type KuatHeaderAppSwitcherEmpty = (typeof KUAT_HEADER_APP_SWITCHER_EMPTY)[number];
+export interface KuatHeaderApp {
+    id: string;
+    label: string;
+    href: string;
+    description?: string;
+    icon?: React.ReactNode;
+}
+export interface KuatHeaderAppSwitcherLabels {
+    trigger?: string;
+    nav?: string;
+    title?: string;
+    teaserTitle?: string;
+    teaserDescription?: string;
+}
+export interface KuatHeaderAppSwitcherConfig {
+    apps: KuatHeaderApp[];
+    loading?: boolean;
+    empty?: KuatHeaderAppSwitcherEmpty;
+    emptyMessage?: string;
+    linkTarget?: React.HTMLAttributeAnchorTarget;
+    labels?: KuatHeaderAppSwitcherLabels;
+    onOpen?: () => void;
+    onSelect?: (app: KuatHeaderApp) => void;
+}
+export interface KuatHeaderAccountItem {
+    label: string;
+    href: string;
+    icon?: React.ReactNode;
+}
+export interface KuatHeaderAccountMobileTier {
+    heading: string;
+    subtitle?: string;
+    items: KuatHeaderAccountItem[];
+}
+export interface KuatHeaderAccountLabels {
+    teaserTitle?: string;
+    teaserDescription?: string;
+    nav?: string;
+    title?: string;
+}
+export interface KuatHeaderAccountConfig {
+    items: KuatHeaderAccountItem[];
+    mobile?: KuatHeaderAccountMobileTier;
+    labels?: KuatHeaderAccountLabels;
+}
+export interface KuatHeaderLockupConfig {
+    variant: KuatHeaderLockupVariant;
+}
+export interface KuatHeaderSubItem {
+    label: string;
+    url: string;
+}
+export interface KuatHeaderNavItem extends KuatHeaderSubItem {
+    items?: KuatHeaderSubItem[];
+}
+/** @deprecated Use `KuatHeaderAccountItem` with `href`. */
+export interface KuatHeaderActionItem {
+    label: string;
+    url: string;
+    icon?: React.ReactNode;
+    items?: KuatHeaderSubItem[];
+}
+export interface KuatHeaderProps extends React.HTMLAttributes<HTMLElement> {
+    variant?: KuatHeaderVariant;
+    title?: string;
+    /** Custom logo node. `null` hides logo. Built-in EE logo only when `lockup` is set. */
+    logo?: React.ReactNode | null;
+    lockup?: KuatHeaderLockupConfig;
+    navigation?: React.ReactNode | KuatHeaderNavItem[];
+    /** Structured account chrome (desktop links + optional mobile tier). */
+    account?: KuatHeaderAccountConfig;
+    /** Custom account / actions markup (escape hatch). */
+    accountMarkup?: React.ReactNode;
+    appSwitcher?: KuatHeaderAppSwitcherConfig;
+    mobileMenuTrigger?: React.ReactNode;
+    mobileMenu?: React.ReactNode;
+    mobileMenuAriaLabel?: string;
+}
+export interface EELogoProps {
+    className?: string;
+    textColor?: EELogoTextColor;
+}

package/dist/components/ui/kuat-logo-lockup/index.d.ts

@@ -0,0 +1,2 @@
+export { KuatLogoLockup, KUAT_LOGO_LOCKUP_USE, KUAT_LOGO_LOCKUP_MODE } from './kuat-logo-lockup';
+export type { KuatLogoLockupProps, KuatLogoLockupUse, KuatLogoLockupMode, } from './kuat-logo-lockup';

package/dist/components/ui/kuat-logo-lockup/kuat-logo-lockup.d.ts

@@ -0,0 +1,17 @@
+import * as React from "react";
+export declare const KUAT_LOGO_LOCKUP_USE: readonly ["service", "demo"];
+export type KuatLogoLockupUse = (typeof KUAT_LOGO_LOCKUP_USE)[number];
+export declare const KUAT_LOGO_LOCKUP_MODE: readonly ["light", "dark"];
+export type KuatLogoLockupMode = (typeof KUAT_LOGO_LOCKUP_MODE)[number];
+export interface KuatLogoLockupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Service name (Service use) or primary title (Demo use) */
+    title: string;
+    /** Service: logo first + name. Demo: title primary, "A demo by" + small logo. */
+    use?: KuatLogoLockupUse;
+    /** Visual theme */
+    mode?: KuatLogoLockupMode;
+    /** When true, force dark styling (e.g. on dark background) */
+    forceDark?: boolean;
+}
+declare const KuatLogoLockup: React.ForwardRefExoticComponent<KuatLogoLockupProps & React.RefAttributes<HTMLDivElement>>;
+export { KuatLogoLockup };

package/dist/components/ui/kuat-radial-progress/index.d.ts

@@ -0,0 +1,2 @@
+export { KuatRadialProgress, KUAT_RADIAL_PROGRESS_SIZES, KUAT_RADIAL_PROGRESS_COLORS, } from './kuat-radial-progress';
+export type { KuatRadialProgressProps, KuatRadialProgressSize, KuatRadialProgressColor, } from './kuat-radial-progress';

package/dist/components/ui/kuat-radial-progress/kuat-radial-progress.d.ts

@@ -0,0 +1,16 @@
+import * as React from "react";
+export declare const KUAT_RADIAL_PROGRESS_SIZES: readonly ["mini", "small", "medium", "large"];
+export declare const KUAT_RADIAL_PROGRESS_COLORS: readonly ["default", "primary", "ee-blue", "tech-blue", "transform-teal", "equal-ember"];
+export type KuatRadialProgressSize = (typeof KUAT_RADIAL_PROGRESS_SIZES)[number];
+export type KuatRadialProgressColor = (typeof KUAT_RADIAL_PROGRESS_COLORS)[number];
+export interface KuatRadialProgressProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "color"> {
+    /** Value from 0 to 100 */
+    value: number;
+    /** Bar colour from Kuat palette; default uses semantic foreground-bar token */
+    color?: KuatRadialProgressColor;
+    size?: KuatRadialProgressSize;
+    /** When true, animate from 0 to value on mount */
+    animate?: boolean;
+}
+declare const KuatRadialProgress: React.ForwardRefExoticComponent<KuatRadialProgressProps & React.RefAttributes<HTMLDivElement>>;
+export { KuatRadialProgress };

package/dist/components/ui/radio/index.d.ts

@@ -0,0 +1,4 @@
+export { RadioGroup, RadioGroupItem } from './radio';
+export type { RadioGroupProps, RadioGroupItemProps } from './radio';
+export { RadioField, RADIO_FIELD_APPEARANCES, RADIO_FIELD_LAYOUTS, } from './radio-field';
+export type { RadioFieldAppearance, RadioFieldLayout, RadioFieldProps, } from './radio-field';

package/dist/components/ui/radio/radio-field.d.ts

@@ -0,0 +1,25 @@
+import { RadioGroupItem } from './radio';
+import * as React from "react";
+export declare const RADIO_FIELD_APPEARANCES: readonly ["plain", "card"];
+export type RadioFieldAppearance = (typeof RADIO_FIELD_APPEARANCES)[number];
+export declare const RADIO_FIELD_LAYOUTS: readonly ["inline", "block"];
+export type RadioFieldLayout = (typeof RADIO_FIELD_LAYOUTS)[number];
+/** @deprecated Prefer composing `Field` + `RadioGroupItem` for new form layouts. */
+export interface RadioFieldProps extends Omit<React.ComponentPropsWithoutRef<typeof RadioGroupItem>, "id" | "children"> {
+    /** Primary label (always shown). */
+    label: React.ReactNode;
+    /** Optional secondary line (12px muted); works for both plain and card. */
+    secondaryText?: React.ReactNode;
+    /** `plain` — no border/padding; `card` — bordered padded container (Figma Rich). */
+    appearance?: RadioFieldAppearance;
+    /** `inline` — compact label; `block` — label row can grow (Figma Radio Group). */
+    layout?: RadioFieldLayout;
+    /** Place radio on the right of the text block. */
+    flipped?: boolean;
+    id?: string;
+    /** Required — must match a unique option in the parent `RadioGroup`. */
+    value: string;
+}
+/** @deprecated Prefer composing `Field` + `RadioGroupItem` for new form layouts. */
+declare const RadioField: React.ForwardRefExoticComponent<RadioFieldProps & React.RefAttributes<HTMLButtonElement>>;
+export { RadioField };

package/dist/components/ui/radio/radio.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+declare const RadioGroup: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const RadioGroupItem: React.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export type RadioGroupProps = React.ComponentPropsWithoutRef<typeof RadioGroup>;
+export type RadioGroupItemProps = React.ComponentPropsWithoutRef<typeof RadioGroupItem>;
+export { RadioGroup, RadioGroupItem };

package/dist/components/ui/select/constants.d.ts

@@ -0,0 +1,19 @@
+import type * as React from "react";
+export declare const SELECT_SIZES: readonly ["regular", "large", "small", "mini"];
+export type SelectSize = (typeof SELECT_SIZES)[number];
+export declare const SELECT_LINES: readonly ["single", "double"];
+export type SelectLines = (typeof SELECT_LINES)[number];
+export interface SelectItemOption {
+    value: string;
+    label: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    prepend?: React.ReactNode;
+    decoration?: React.ReactNode;
+}
+export interface SelectItemGroup {
+    label: React.ReactNode;
+    items: SelectItemOption[];
+}
+export type SelectItems = Array<SelectItemOption | SelectItemGroup>;
+export declare function isSelectItemGroup(item: SelectItemOption | SelectItemGroup): item is SelectItemGroup;

package/dist/components/ui/select/index.d.ts

@@ -0,0 +1,3 @@
+export { KuatSelect, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SELECT_LINES, SELECT_SIZES, } from './select';
+export type { KuatSelectProps, SelectContentProps, SelectItemProps, SelectLabelProps, SelectProps, SelectSeparatorProps, SelectTriggerProps, SelectValueProps, } from './select';
+export type { SelectItemGroup, SelectItemOption, SelectItems, SelectLines, SelectSize, } from './constants';

package/dist/components/ui/select/select.d.ts

@@ -0,0 +1,53 @@
+import { SELECT_LINES, SELECT_SIZES, SelectItems, SelectLines, SelectSize } from './constants';
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    size?: SelectSize;
+    lines?: SelectLines;
+    label?: React.ReactNode;
+    prepend?: React.ReactNode;
+    decoration?: React.ReactNode;
+    invalid?: boolean;
+} & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    size?: SelectSize;
+    maxHeight?: number | string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface SelectItemProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> {
+    prepend?: React.ReactNode;
+    description?: React.ReactNode;
+    decoration?: React.ReactNode;
+}
+declare const SelectItem: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface KuatSelectProps extends Omit<React.ComponentPropsWithoutRef<typeof SelectPrimitive.Root>, "children"> {
+    items?: SelectItems;
+    placeholder?: string;
+    size?: SelectSize;
+    lines?: SelectLines;
+    prepend?: React.ReactNode;
+    decoration?: React.ReactNode;
+    label?: React.ReactNode;
+    invalid?: boolean;
+    position?: React.ComponentPropsWithoutRef<typeof SelectContent>["position"];
+    maxHeight?: number | string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    emptyText?: React.ReactNode;
+    children?: React.ReactNode;
+    triggerProps?: Omit<React.ComponentPropsWithoutRef<typeof SelectTrigger>, "children" | "size" | "lines" | "label" | "prepend" | "decoration" | "invalid">;
+}
+declare function KuatSelect({ items, placeholder, size, lines, prepend, decoration, label, invalid, position, maxHeight, triggerClassName, contentClassName, emptyText, children, triggerProps, ...rootProps }: KuatSelectProps): import("react/jsx-runtime").JSX.Element;
+export type SelectProps = React.ComponentPropsWithoutRef<typeof Select>;
+export type SelectTriggerProps = React.ComponentPropsWithoutRef<typeof SelectTrigger>;
+export type SelectContentProps = React.ComponentPropsWithoutRef<typeof SelectContent>;
+export type SelectLabelProps = React.ComponentPropsWithoutRef<typeof SelectLabel>;
+export type SelectSeparatorProps = React.ComponentPropsWithoutRef<typeof SelectSeparator>;
+export type SelectValueProps = React.ComponentPropsWithoutRef<typeof SelectValue>;
+export { KuatSelect, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SELECT_LINES, SELECT_SIZES, };

package/dist/components/ui/separator/index.d.ts

@@ -0,0 +1,2 @@
+export { Separator, SEPARATOR_ORIENTATIONS } from './separator';
+export type { SeparatorProps, SeparatorOrientation } from './separator';

package/dist/components/ui/separator/separator.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+export declare const SEPARATOR_ORIENTATIONS: readonly ["horizontal", "vertical"];
+export type SeparatorOrientation = (typeof SEPARATOR_ORIENTATIONS)[number];
+export interface SeparatorProps extends React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root> {
+    orientation?: SeparatorOrientation;
+}
+declare const Separator: React.ForwardRefExoticComponent<SeparatorProps & React.RefAttributes<HTMLDivElement>>;
+export { Separator };