themelia-react-ui 0.0.0-stage → 1.0.0

package/dist/components/base/navigation/pagination.d.ts

@@ -0,0 +1,61 @@
+import { type ComponentProps, type ReactNode } from 'react';
+import { Pagination as UIPagination, PaginationContent as UIPaginationContent, PaginationItem as UIPaginationItem } from '../../ui/pagination';
+import { type ButtonProps } from '../buttons';
+import { type StringsProp } from '../../../lib/strings';
+export interface PaginationStrings {
+    navigationLabel: string;
+    morePages: string;
+    previous: string;
+    next: string;
+    previousLabel: string;
+    nextLabel: string;
+}
+export declare const defaultPaginationStrings: PaginationStrings;
+export interface PaginationProps extends ComponentProps<typeof UIPagination> {
+    /** Pagination items, normally blocks through `PaginationContent`. */
+    children?: ReactNode;
+    /** Accessible label for the pagination navigation landmark. */
+    'aria-label'?: string;
+    /** Additional classes merged with the package pagination root hook. */
+    className?: string;
+    /** Localizable navigation, direction, and ellipsis labels inherited by compound parts. */
+    strings?: StringsProp<PaginationStrings>;
+}
+export type PaginationContentProps = ComponentProps<typeof UIPaginationContent>;
+export type PaginationEllipsisProps = ComponentProps<'span'> & {
+    /** Copy for the control. */
+    label?: string;
+    /** Overrides the pagination copy. */
+    strings?: StringsProp<PaginationStrings>;
+};
+export type PaginationItemProps = ComponentProps<typeof UIPaginationItem>;
+export interface PaginationLinkProps extends Omit<ButtonProps, 'buttonStyle' | 'children' | 'variant'> {
+    children?: ReactNode;
+    /** Marks the current page. */
+    active?: boolean;
+}
+export type PaginationNextProps = PaginationLinkProps & {
+    /** Visible label for the control. */
+    text?: string;
+    /** Overrides the pagination copy. */
+    strings?: StringsProp<PaginationStrings>;
+};
+export type PaginationPreviousProps = PaginationLinkProps & {
+    /** Visible label for the control. */
+    text?: string;
+    /** Overrides the pagination copy. */
+    strings?: StringsProp<PaginationStrings>;
+};
+/**
+ * Tokenized pagination navigation root.
+ *
+ * Compose it with the exported content, item, link, previous, next, and
+ * ellipsis parts when consumers need explicit page navigation markup.
+ */
+export declare function PaginationPrimitive({ className, strings: stringsProp, children, 'aria-label': ariaLabel, ...props }: PaginationProps): import("react").JSX.Element;
+export declare function PaginationContent({ className, ...props }: PaginationContentProps): import("react").JSX.Element;
+export declare function PaginationEllipsis({ className, label, strings: stringsProp, ...props }: PaginationEllipsisProps): import("react").JSX.Element;
+export declare function PaginationItem(props: PaginationItemProps): import("react").JSX.Element;
+export declare function PaginationLink({ className, children, active, ...props }: PaginationLinkProps): import("react").JSX.Element;
+export declare function PaginationPrevious({ className, text, strings: stringsProp, children: _children, ...props }: PaginationPreviousProps): import("react").JSX.Element;
+export declare function PaginationNext({ className, text, strings: stringsProp, children: _children, ...props }: PaginationNextProps): import("react").JSX.Element;

package/dist/components/base/navigation/tab-scroll-viewport.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import { type StringsProp } from '../../../lib/strings';
+export interface TabsScrollStrings {
+    previous: string;
+    next: string;
+}
+export declare const defaultTabsScrollStrings: TabsScrollStrings;
+/** Shared scroll mechanics for state tabs and route tabs; selection stays with each owner. */
+export declare function TabScrollViewport({ children, strings: stringsProp }: {
+    children: ReactNode;
+    strings?: StringsProp<TabsScrollStrings>;
+}): import("react").JSX.Element;

package/dist/components/base/navigation/tabs.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Typography- and token-aware wrappers around the internal shadcn tabs parts.
+ *
+ * The shadcn source is left untouched, so its literal `gap-1.5 rounded-md px-2
+ * py-1` reached consumers unchanged and opted tabs out of scoped `--space-scale`
+ * and `--radius` overrides — the only interactive family in the package that
+ * did. These wrappers restate the same values as tokens; `cn` merges them last,
+ * so they win. Every value below is pixel-identical to the primitive's default.
+ */
+import type { ComponentProps } from 'react';
+import { Tabs as PrimitiveTabs, TabsContent as PrimitiveTabsContent, TabsList as PrimitiveTabsList, TabsTrigger as PrimitiveTabsTrigger } from '../../ui/tabs';
+import type { StringsProp } from '../../../lib/strings';
+import { type TabsScrollStrings } from './tab-scroll-viewport';
+export declare function Tabs({ className, ...props }: ComponentProps<typeof PrimitiveTabs>): import("react").JSX.Element;
+export type TabsListProps = ComponentProps<typeof PrimitiveTabsList> & {
+    /** Adds previous/next controls when the tab list exceeds its container. */
+    scrollable?: boolean;
+    /** Accessible labels for the previous/next scroll controls. */
+    scrollStrings?: StringsProp<TabsScrollStrings>;
+};
+export declare function TabsList({ className, scrollable, scrollStrings, ...props }: TabsListProps): import("react").JSX.Element;
+export declare function TabsTrigger({ className, children, ...props }: ComponentProps<typeof PrimitiveTabsTrigger>): import("react").JSX.Element;
+export declare function TabsContent({ className, children, ...props }: ComponentProps<typeof PrimitiveTabsContent>): import("react").JSX.Element;

package/dist/components/base/popover/collection-content.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+/** Presentation only. Interactive primitives retain identity and behavior. */
+export declare function CollectionLabel({ children, className }: {
+    children: ReactNode;
+    className?: string;
+}): string | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+interface CollectionContentProps {
+    label: ReactNode;
+    description?: ReactNode;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    leadingDecorative?: boolean;
+    wrap?: boolean;
+    className?: string;
+    leadingClassName?: string;
+    bodyClassName?: string;
+    labelClassName?: string;
+    descriptionClassName?: string;
+}
+/** Private copy grammar shared by option/action owners; rich slots are not cloned. */
+export declare function CollectionContent({ label, description, leading, trailing, leadingDecorative, wrap, className, leadingClassName, bodyClassName, labelClassName, descriptionClassName, }: CollectionContentProps): import("react").JSX.Element;
+export {};

package/dist/components/base/popover/index.d.ts

@@ -0,0 +1 @@
+export { Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverFooter, PopoverHeader, PopoverTitle, PopoverTrigger, type PopoverContentInset, type PopoverContentProps, type PopoverContentType, } from './popover';

package/dist/components/base/popover/popover.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Popover — public wrapper around the internal Base UI popover implementation.
+ *
+ * What this layer adds on top of the primitive:
+ *  - Library-default `sideOffset` (6px) and an explicit inset contract:
+ *    card/multi-content popovers use `default`, item collections use
+ *    `compact`, and mixed region-owned compositions use `flush`.
+ *  - A consistent shadow + border treatment matching the rest of the
+ *    library (one semantic border, no extra primitive ring).
+ *  - Wraps the primitive parts with stable DOM hooks and adds a separated
+ *    footer region while preserving the compound-component pattern:
+ *    `<Popover>`, `<PopoverTrigger>`, `<PopoverContent>` exactly as
+ *    they would with the primitive.
+ *
+ * Use the shared inset role for padding; className owns placement. Override
+ * `--surface-x` / `--surface-y` / `--space-scale` on a wrapper for surface-wide
+ * density tweaks.
+ */
+import * as React from 'react';
+import { Popover as PopoverPrimitive, PopoverAnchor, PopoverContent as PopoverContentPrimitive, PopoverDescription as PopoverDescriptionPrimitive, PopoverHeader as PopoverHeaderPrimitive, PopoverTitle as PopoverTitlePrimitive, PopoverTrigger } from '../../ui/popover';
+import { type TextGap } from '../structure';
+import { type PopoverContentType } from './popover.recipes';
+export type { PopoverContentType } from './popover.recipes';
+type PopoverContentBaseProps = React.ComponentProps<typeof PopoverContentPrimitive>;
+export type PopoverContentInset = 'default' | 'compact' | 'flush';
+export type PopoverContentProps = PopoverContentBaseProps & {
+    /**
+     * Surface inset role. `default` is for card-like or multi-content popovers,
+     * `compact` for pure item/option collections, and `flush` when child regions
+     * own their padding.
+     */
+    inset?: PopoverContentInset;
+    /** Anatomy role; supplies the inferred inset only when inset is omitted. */
+    type?: PopoverContentType;
+};
+/** Anchored content surface with a semantic inset role and package popover chrome. */
+declare function PopoverContent({ className, sideOffset, inset, type, style, ...props }: PopoverContentProps): React.JSX.Element;
+type PopoverHeaderBaseProps = React.ComponentProps<typeof PopoverHeaderPrimitive> & {
+    /** Leading control, aligned with collection highlight edges rather than label text. */
+    start?: React.ReactNode;
+    /** Copy rhythm. Defaults to dense for menus and normal for display surfaces. */
+    textGap?: TextGap;
+};
+declare function PopoverHeader({ className, children, start, textGap, ...props }: PopoverHeaderBaseProps): React.JSX.Element;
+type PopoverTitleBaseProps = React.ComponentProps<typeof PopoverTitlePrimitive>;
+declare function PopoverTitle({ children, className, ...props }: PopoverTitleBaseProps): React.JSX.Element;
+type PopoverDescriptionBaseProps = React.ComponentProps<typeof PopoverDescriptionPrimitive>;
+declare function PopoverDescription({ children, className, ...props }: PopoverDescriptionBaseProps): React.JSX.Element;
+type PopoverFooterProps = React.ComponentProps<'div'> & {
+    /** Leading supporting content, aligned with collection labels; children are trailing actions. */
+    caption?: React.ReactNode;
+};
+declare function PopoverFooter({ className, children, caption, ...props }: PopoverFooterProps): React.JSX.Element;
+export { PopoverPrimitive as Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverFooter, PopoverHeader, PopoverTitle, PopoverTrigger, };

package/dist/components/base/popover/popover.recipes.d.ts

@@ -0,0 +1,29 @@
+import { type RowDensity } from '../../../lib/row-recipes';
+/** Shared anchored-surface chrome; Menu and Popover retain their own accessible behavior. */
+export declare const popoverRecipes: {
+    readonly surface: "rounded-radius border border-border/60 bg-popover text-popover-foreground shadow-md ring-0";
+    readonly display: "p-surface";
+    readonly menu: "p-surface-xs";
+    readonly menuRegion: "px-surface-xs py-space-md";
+    readonly separator: "mx-0 my-space-xs h-px w-full shrink-0 bg-border/60";
+    readonly row: "min-h-control rounded-inner px-row-x gap-space-sm font-medium leading-tight";
+};
+export type PopoverContentType = 'display' | 'menu';
+/** One surface inset vocabulary for Popover, Command and their collections. */
+export declare const surfaceInsetClasses: {
+    readonly default: "p-surface";
+    readonly compact: "p-surface-xs";
+    readonly flush: "p-0";
+};
+/** Collection density changes vertical rhythm; inline room and primary text stay stable. */
+export type CollectionDensity = RowDensity;
+export declare function collectionRowClasses(density?: CollectionDensity): string;
+/** Shared interactive collection states, independent of Menu/listbox state ownership. */
+export declare const collectionRecipes: {
+    readonly icons: "[&_svg]:pointer-events-none [&_svg]:size-icon [&_svg]:shrink-0";
+    readonly interactive: "relative flex cursor-default items-center outline-none select-none transition-colors";
+    readonly highlighted: "data-highlighted:bg-accent data-highlighted:text-accent-foreground data-highlighted:[&_svg]:text-accent-foreground";
+    readonly disabled: "data-disabled:pointer-events-none data-disabled:opacity-50";
+    readonly destructive: "data-[variant=destructive]:text-destructive data-[variant=destructive]:data-highlighted:bg-destructive/10 data-[variant=destructive]:data-highlighted:text-destructive dark:data-[variant=destructive]:data-highlighted:bg-destructive/20 data-[variant=destructive]:[&_svg]:text-destructive data-[variant=destructive]:data-highlighted:[&_svg]:text-destructive";
+    readonly tableRow: "min-h-action-xs py-space-2xs";
+};

package/dist/components/base/popover-menu/index.d.ts

@@ -0,0 +1,3 @@
+export { PopoverMenu } from './popover-menu';
+export type { PopoverMenuProps, PopoverMenuRenderItemContext, } from './popover-menu';
+export { defaultPopoverMenuStrings, type PopoverMenuItem, type PopoverMenuStrings, } from './popover-menu.types';

package/dist/components/base/popover-menu/popover-menu.d.ts

@@ -0,0 +1,82 @@
+/**
+ * PopoverMenu — blocks wrapper around `base/popover` + `base/command`.
+ *
+ * Captures the recurring "trigger → optional header → search → command list"
+ * pattern used by filter facets, operator selects, and similar pickers
+ * across the library.
+ *
+ * Slots (all optional):
+ *   - `header`   — rendered above the search input / list
+ *   - `footer`   — rendered below the list (e.g. confirm/clear buttons)
+ *   - `empty`    — replaces the default empty-state copy
+ *   - `loading`  — replaces the list when `loading` is true
+ *
+ * Render-prop:
+ *   - `renderItem={(item, ctx) => ReactNode}` — full control over a row
+ *
+ * Strings:
+ *   - `strings={{ searchPlaceholder, empty, loading }}` — merged with defaults
+ *
+ * For headless usage (custom UI against the same selection state),
+ * compose `base/popover` + `base/command` directly.
+ */
+import * as React from 'react';
+import { PopoverContent } from '../popover';
+import { type StringsProp } from '../../../lib/strings';
+import { type CollectionDensity } from '../popover/popover.recipes';
+import { type PopoverMenuItem, type PopoverMenuStrings } from './popover-menu.types';
+export interface PopoverMenuRenderItemContext {
+    /** True when the item is the user's currently-active match (keyboard or pointer highlight). */
+    isHighlighted: boolean;
+}
+export interface PopoverMenuProps<T = unknown> {
+    /** Vertical row rhythm. Compact and comfortable preserve primary label size and inline room. */
+    density?: CollectionDensity;
+    /** Trigger element. The popover anchors to it. Pass any clickable. */
+    trigger: React.ReactNode;
+    /** Items to render in the list. */
+    items: ReadonlyArray<PopoverMenuItem<T>>;
+    /** Selection callback — fires on row click / Enter. */
+    onSelect: (item: PopoverMenuItem<T>) => void;
+    /** Controlled open state. Omit for uncontrolled. */
+    open?: boolean;
+    /** Open-state callback for controlled / uncontrolled flows. */
+    onOpenChange?: (open: boolean) => void;
+    /** Show the search input above the list. Default: true. */
+    search?: boolean;
+    /** Search input value (controlled). */
+    searchValue?: string;
+    /** Search input change callback. */
+    onSearchChange?: (value: string) => void;
+    /** Async loading flag — replaces stale options and the empty state. */
+    loading?: boolean;
+    /** Resource failure replaces the list. The application owns retry and fetching. */
+    error?: React.ReactNode;
+    onRetry?: () => void;
+    /** Optional pre-list slot (e.g. a label / eyebrow). */
+    header?: React.ReactNode;
+    /** Optional post-list slot (e.g. confirm / clear buttons). */
+    footer?: React.ReactNode;
+    /** Override empty-state slot (defaults to `strings.empty`). */
+    empty?: React.ReactNode;
+    /** Override loading slot (defaults to spinner + `strings.loading`). */
+    loadingSlot?: React.ReactNode;
+    /** Per-item render override. */
+    renderItem?: (item: PopoverMenuItem<T>, ctx: PopoverMenuRenderItemContext) => React.ReactNode;
+    /** Override copy. Deep-merged over defaults. */
+    strings?: StringsProp<PopoverMenuStrings>;
+    /** Popover content positioning props (forwarded). */
+    align?: React.ComponentProps<typeof PopoverContent>['align'];
+    /** Distance from the trigger, in pixels. */
+    sideOffset?: React.ComponentProps<typeof PopoverContent>['sideOffset'];
+    /** Width override for the popover content. Default: w-56. */
+    contentClassName?: string;
+    /** Accessible name for the popup. Defaults to the localized search label. */
+    contentLabel?: string;
+    /** ID of a consumer-owned title used instead of contentLabel. */
+    contentLabelledBy?: string;
+}
+export declare function PopoverMenu<T = unknown>({ density, trigger, items, onSelect, open, onOpenChange, search, searchValue, onSearchChange, loading, error, onRetry, header, footer, empty, loadingSlot, renderItem, strings: stringsProp, align, sideOffset, contentClassName, contentLabel, contentLabelledBy, }: PopoverMenuProps<T>): React.JSX.Element;
+export declare namespace PopoverMenu {
+    var displayName: string;
+}

package/dist/components/base/popover-menu/popover-menu.types.d.ts

@@ -0,0 +1,30 @@
+import type { ReactNode } from 'react';
+export interface PopoverMenuItem<T = unknown> {
+    /** Unique identifier; remains distinct from visible search labels. */
+    value: string;
+    /** Visible label rendered in the row. Override entirely via `renderItem`. */
+    label: ReactNode;
+    /** Optional secondary line rendered under the label. */
+    description?: ReactNode;
+    /** Leading icon — keep small (size-icon-md/size-icon max). */
+    icon?: ReactNode;
+    /** Show the trailing checkmark when `true`. */
+    selected?: boolean;
+    /** Disable the row. */
+    disabled?: boolean;
+    /** Explicit search keywords, useful when the label is structured content. */
+    searchValue?: string;
+    /** Arbitrary payload for `onSelect` consumers. */
+    data?: T;
+}
+export interface PopoverMenuStrings {
+    /** Placeholder for the search input (when `search` is enabled). */
+    searchPlaceholder: string;
+    /** Empty-state copy when filtering yields no items. */
+    empty: string;
+    /** Loading-state copy. */
+    loading: string;
+    /** Retry action copy when a resource fails. */
+    retry?: string;
+}
+export declare const defaultPopoverMenuStrings: PopoverMenuStrings;

package/dist/components/base/qr-code/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * QR code rendering.
+ *
+ * Published as its own `themelia-react-ui/base/qr-code` entrypoint so the
+ * optional `qrcode` and `culori` peers stay isolated from the broad base
+ * barrels.
+ */
+export { QRCode, type QRCodeProps } from './qr-code';

package/dist/components/base/qr-code/qr-code.d.ts

@@ -0,0 +1,13 @@
+import { type HTMLAttributes } from 'react';
+export type QRCodeProps = HTMLAttributes<HTMLDivElement> & {
+    data: string;
+    foreground?: string;
+    background?: string;
+    robustness?: 'L' | 'M' | 'Q' | 'H';
+};
+export declare const QRCode: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    data: string;
+    foreground?: string;
+    background?: string;
+    robustness?: "L" | "M" | "Q" | "H";
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/repeaters/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Repeating and locale-keyed field collections.
+ *
+ * `Repeater` is the presentational engine — add/remove/reorder rows around a
+ * render prop — and is the only member that works without `react-hook-form`.
+ * Everything else in this family opts into RHF on purpose: they manage nested
+ * arrays and locale-keyed objects, which is exactly what RHF's field-array and
+ * form-context APIs exist for. Apps not using RHF should stay on `Repeater`.
+ *
+ * The localized field set (`LocalizedStringField`, `LocalizedObjectField`,
+ * `LocalizedStringRepeater`) edits per-locale objects such as
+ * `{ en: '…', bg: '…' }` behind a single field surface.
+ */
+export { Repeater, defaultRepeaterPrimitiveStrings, type RepeaterComponentProps, type RepeaterProps, type RepeaterStrings, type RepeaterItem, type RepeaterRowRenderContext, type RepeaterRowVariant, type RepeaterRemoveVariant, } from './repeater';
+export { StringRepeater, defaultStringRepeaterStrings, type StringRepeaterProps, type StringRepeaterStrings, type StringRepeaterFieldRenderContext, } from './string-repeater';
+export { ObjectRepeater, defaultObjectRepeaterStrings, type ObjectRepeaterProps, type ObjectRepeaterStrings, type ObjectRepeaterFieldRenderContext, type ObjectFieldDef, } from './object-repeater';
+export { defaultRepeaterStrings, type RepeaterSharedStrings, } from './repeaters.strings';
+export { KeyValueEditor, type KeyValueEditorProps, type KeyValuePair } from './key-value-editor';
+export { LocalizedStringField, type LocalizedStringFieldProps } from './localized-string-field';
+export { LocalizedObjectField, type LocalizedObjectFieldProps, type LocalizedObjectFieldDef } from './localized-object-field';
+export { LocalizedStringRepeater, defaultLocalizedStringRepeaterStrings, type LocalizedStringRepeaterProps, type LocalizedStringRepeaterStrings, } from './localized-string-repeater';

package/dist/components/base/repeaters/key-value-editor.d.ts

@@ -0,0 +1,27 @@
+import { type StringsProp } from '../../../lib/strings';
+export type KeyValuePair = {
+    key: string;
+    value: string;
+};
+export interface KeyValueEditorStrings {
+    keyLabel: string;
+    valueLabel: string;
+    keyPlaceholder: string;
+    valuePlaceholder: string;
+    addButton: string;
+    removeRowAriaLabel: string;
+    emptyState: string;
+}
+export declare const defaultKeyValueEditorStrings: KeyValueEditorStrings;
+export interface KeyValueEditorProps {
+    /** Current value. Controlled. */
+    value?: Record<string, string>;
+    onValueChange?: (val: Record<string, string>) => void;
+    /** Applies the invalid styling. */
+    invalid?: boolean;
+    /** Enable drag-to-reorder. Default `false`. */
+    sortable?: boolean;
+    /** Override default strings (labels, placeholders, button text). */
+    strings?: StringsProp<KeyValueEditorStrings>;
+}
+export declare const KeyValueEditor: import("react").ForwardRefExoticComponent<KeyValueEditorProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/base/repeaters/localized-object-field.d.ts

@@ -0,0 +1,35 @@
+export interface LocalizedObjectFieldDef {
+    /** Field name within the object */
+    name: string;
+    /** Label for the field */
+    label: string;
+    /** Input type */
+    type?: 'text' | 'textarea' | 'number';
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the field is required */
+    required?: boolean;
+}
+export interface LocalizedObjectFieldProps {
+    /** Field name (path in form values) - should point to object with locale keys */
+    name: string;
+    /** Field definitions for the object properties */
+    fields: LocalizedObjectFieldDef[];
+    /** Primary locale code (e.g., 'en') */
+    primaryLocale: string;
+    /** Secondary locale code (e.g., 'bg') */
+    secondaryLocale: string;
+    /** Current active locale ('primary' or 'secondary') */
+    activeLocale: 'primary' | 'secondary';
+    /** Error state for styling (passed from FormField) */
+    invalid?: boolean;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * LocalizedObjectField - Input for bilingual object fields
+ */
+export declare function LocalizedObjectField({ name, fields, primaryLocale, secondaryLocale, activeLocale, invalid, className, }: LocalizedObjectFieldProps): import("react").JSX.Element;
+export declare namespace LocalizedObjectField {
+    var displayName: string;
+}

package/dist/components/base/repeaters/localized-string-field.d.ts

@@ -0,0 +1,25 @@
+export interface LocalizedStringFieldProps {
+    /** Field name (path in form values) - should point to object with locale keys (e.g., 'en' and 'bg') */
+    name: string;
+    /** Input type */
+    type?: 'text' | 'textarea' | 'number';
+    /** Placeholder text */
+    placeholder?: string;
+    /** Primary locale code (e.g., 'en') */
+    primaryLocale: string;
+    /** Secondary locale code (e.g., 'bg') */
+    secondaryLocale: string;
+    /** Current active locale ('primary' or 'secondary') */
+    activeLocale: 'primary' | 'secondary';
+    /** Error state for styling (passed from FormField) */
+    invalid?: boolean;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * LocalizedStringField - Input for bilingual string fields
+ */
+export declare function LocalizedStringField({ name, type, placeholder, primaryLocale, secondaryLocale, activeLocale, invalid, className, }: LocalizedStringFieldProps): import("react").JSX.Element;
+export declare namespace LocalizedStringField {
+    var displayName: string;
+}

package/dist/components/base/repeaters/localized-string-repeater.d.ts

@@ -0,0 +1,44 @@
+/**
+ * LocalizedStringRepeater — locale-path adapter over `<StringRepeater>`.
+ * The canonical scalar-array engine stays in StringRepeater; this component
+ * selects the active locale path and swaps the default Input for Textarea.
+ */
+import { type StringsProp } from '../../../lib/strings';
+export interface LocalizedStringRepeaterStrings {
+    /** Placeholder shown in every localized textarea. */
+    placeholder: string;
+    /** Label for the add-row action. */
+    addButton: string;
+    /** Copy shown when the active locale array is empty. */
+    emptyState: string;
+    /** Accessible label for each remove action. */
+    removeAriaLabel: string;
+    /** Accessible label for each drag handle. */
+    dragHandleAriaLabel: string;
+}
+export declare const defaultLocalizedStringRepeaterStrings: LocalizedStringRepeaterStrings;
+export interface LocalizedStringRepeaterProps {
+    /** Field path pointing to an object of locale-keyed `string[]` values. */
+    name: string;
+    /** Primary locale key, for example `en`. */
+    primaryLocale: string;
+    /** Secondary locale key, for example `bg`. */
+    secondaryLocale: string;
+    /** Selects which locale array is currently editable. */
+    activeLocale: 'primary' | 'secondary';
+    /** Enable drag-to-reorder. Default `false`. */
+    sortable?: boolean;
+    /** Force invalid styling in addition to React Hook Form state. */
+    invalid?: boolean;
+    /** Disable editing and all row actions. */
+    disabled?: boolean;
+    /** Override default strings. */
+    strings?: StringsProp<LocalizedStringRepeaterStrings>;
+    /** Class applied to the public repeater root. */
+    className?: string;
+}
+/** Locale-path adapter over the canonical StringRepeater array engine. */
+export declare function LocalizedStringRepeater({ name, primaryLocale, secondaryLocale, activeLocale, invalid, disabled, sortable, strings: stringsProp, className, }: LocalizedStringRepeaterProps): import("react").JSX.Element;
+export declare namespace LocalizedStringRepeater {
+    var displayName: string;
+}

package/dist/components/base/repeaters/object-repeater.d.ts

@@ -0,0 +1,66 @@
+/**
+ * ObjectRepeater — RHF-driven repeater for arrays of homogeneous objects.
+ * Field definitions describe the shape of each row (label, type, placeholder,
+ * required, hint); the repeater wires each cell through `useFieldArray` and
+ * renders rows as bordered cards via the shared `<Repeater>` primitive.
+ * Strings overridable for i18n.
+ */
+import { type ReactNode } from 'react';
+import { type UseFormRegisterReturn } from 'react-hook-form';
+import { type StringsProp } from '../../../lib/strings';
+export interface ObjectRepeaterStrings {
+    addButton: string;
+    emptyState: string;
+    removeAriaLabel: string;
+    dragHandleAriaLabel: string;
+}
+export declare const defaultObjectRepeaterStrings: ObjectRepeaterStrings;
+export interface ObjectFieldDef {
+    /** Field name within the object */
+    name: string;
+    /** Label for the field */
+    label: string;
+    /** Input type */
+    type?: 'text' | 'textarea' | 'number';
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Hint text (shown right of label) */
+    hint?: string;
+}
+export interface ObjectRepeaterFieldRenderContext {
+    /** Current object row position. */
+    index: number;
+    /** Fully-qualified React Hook Form field path. */
+    name: string;
+    /** Registration props for the current field. */
+    inputProps: UseFormRegisterReturn;
+    /** Whether invalid styling should be applied. */
+    invalid: boolean;
+    /** Whether editing is disabled. */
+    disabled: boolean;
+}
+export interface ObjectRepeaterProps {
+    /** React Hook Form field path pointing to an object array. */
+    name: string;
+    /** Definitions for each editable property in a row. */
+    fields: ObjectFieldDef[];
+    /** Force invalid styling for every field. */
+    invalid?: boolean;
+    /** Disable editing, addition, removal, and sorting. */
+    disabled?: boolean;
+    /** Enable drag-to-reorder. Default `false`. */
+    sortable?: boolean;
+    /** Replace the default field rendering while retaining array behavior. */
+    renderField?: (field: ObjectFieldDef, context: ObjectRepeaterFieldRenderContext) => ReactNode;
+    /** Override default strings (button labels, empty state). */
+    strings?: StringsProp<ObjectRepeaterStrings>;
+    /** Class applied to the public repeater root. */
+    className?: string;
+}
+/** React Hook Form object-array adapter using the canonical Repeater chrome. */
+export declare function ObjectRepeater({ name, fields: fieldDefs, invalid, disabled, sortable, renderField, strings: stringsProp, className, }: ObjectRepeaterProps): import("react").JSX.Element;
+export declare namespace ObjectRepeater {
+    var displayName: string;
+}