@burdenoff/fe-libs 2026.528.10 → 2026.528.11

package/dist/form/Checkbox.d.ts

@@ -0,0 +1,65 @@
+import * as React from 'react';
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+/**
+ * Checkbox component props
+ */
+export type CheckboxProps = React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>;
+/**
+ * Checkbox component - Accessible checkbox using Radix UI
+ *
+ * A styled checkbox component with proper accessibility features.
+ * Uses Radix UI Checkbox primitive for robust functionality.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <Checkbox id="terms" />
+ * <label htmlFor="terms">Accept terms and conditions</label>
+ * ```
+ *
+ * @example With React Hook Form
+ * ```tsx
+ * <FormField
+ *   control={form.control}
+ *   name="newsletter"
+ *   render={({ field }) => (
+ *     <FormItem className="flex flex-row items-start space-x-3 space-y-0">
+ *       <FormControl>
+ *         <Checkbox
+ *           checked={field.value}
+ *           onCheckedChange={field.onChange}
+ *         />
+ *       </FormControl>
+ *       <div className="space-y-1 leading-none">
+ *         <FormLabel>Subscribe to newsletter</FormLabel>
+ *         <FormDescription>
+ *           Receive updates about new features and announcements
+ *         </FormDescription>
+ *       </div>
+ *     </FormItem>
+ *   )}
+ * />
+ * ```
+ *
+ * @example Controlled checkbox
+ * ```tsx
+ * const [checked, setChecked] = useState(false);
+ *
+ * <Checkbox
+ *   checked={checked}
+ *   onCheckedChange={setChecked}
+ *   disabled={false}
+ * />
+ * ```
+ *
+ * @example Indeterminate state
+ * ```tsx
+ * <Checkbox checked="indeterminate" />
+ * ```
+ */
+export declare function Checkbox({ ref, className, ...props }: CheckboxProps & {
+    ref?: React.Ref<React.ElementRef<typeof CheckboxPrimitive.Root>>;
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace Checkbox {
+    var displayName: string | undefined;
+}
+//# sourceMappingURL=Checkbox.d.ts.map

package/dist/form/Checkbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Checkbox.d.ts","sourceRoot":"","sources":["../../src/form/Checkbox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,iBAAiB,MAAM,0BAA0B,CAAC;AAI9D;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC,wBAAwB,CAAC,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC;AAE1F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,SAAS,EACT,GAAG,KAAK,EACT,EAAE,aAAa,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAA;CAAE,2CAkBtF;yBAtBe,QAAQ"}

package/dist/form/Form.d.ts

@@ -0,0 +1,114 @@
+import { UseFormReturn, SubmitHandler, FieldValues, UseFormProps } from 'react-hook-form';
+import { ZodType } from 'zod';
+import * as React from 'react';
+type FormSchema<TFieldValues extends FieldValues> = ZodType<unknown, TFieldValues>;
+/**
+ * Form component props extending React Hook Form's UseFormProps
+ *
+ * @example
+ * ```tsx
+ * import { z } from 'zod';
+ *
+ * const schema = z.object({
+ *   email: z.string().email(),
+ *   password: z.string().min(8),
+ * });
+ *
+ * function LoginForm() {
+ *   const handleSubmit = (data: z.infer<typeof schema>) => {
+ *     console.log(data);
+ *   };
+ *
+ *   return (
+ *     <Form schema={schema} onSubmit={handleSubmit}>
+ *       {(form) => (
+ *         <>
+ *           <FormField control={form.control} name="email" />
+ *           <FormField control={form.control} name="password" />
+ *           <button type="submit">Submit</button>
+ *         </>
+ *       )}
+ *     </Form>
+ *   );
+ * }
+ * ```
+ */
+export interface FormProps<TFieldValues extends FieldValues> extends Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit' | 'children'> {
+    /** Zod schema for validation */
+    schema?: FormSchema<TFieldValues>;
+    /** Form submission handler */
+    onSubmit: SubmitHandler<TFieldValues>;
+    /** React Hook Form configuration */
+    formOptions?: Omit<UseFormProps<TFieldValues>, 'resolver'>;
+    /** Render prop with form instance */
+    children: (form: UseFormReturn<TFieldValues>) => React.ReactNode;
+}
+/**
+ * Form wrapper component with React Hook Form integration
+ *
+ * Provides FormProvider context and handles form submission with validation.
+ * Integrates with Zod for schema validation via @hookform/resolvers.
+ *
+ * @example
+ * ```tsx
+ * const schema = z.object({
+ *   name: z.string().min(2),
+ *   email: z.string().email(),
+ * });
+ *
+ * <Form
+ *   schema={schema}
+ *   onSubmit={(data) => console.log(data)}
+ *   formOptions={{ defaultValues: { name: '', email: '' } }}
+ * >
+ *   {(form) => (
+ *     <div>
+ *       <FormField control={form.control} name="name" />
+ *       <button type="submit" disabled={form.formState.isSubmitting}>
+ *         Submit
+ *       </button>
+ *     </div>
+ *   )}
+ * </Form>
+ * ```
+ */
+export declare function Form<TFieldValues extends FieldValues>({ schema, onSubmit, formOptions, children, className, ...props }: FormProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access form context
+ *
+ * Re-exports useFormContext from react-hook-form for convenience
+ *
+ * @example
+ * ```tsx
+ * function CustomFormField() {
+ *   const form = useFormContext();
+ *   return <input {...form.register('fieldName')} />;
+ * }
+ * ```
+ */
+export { useFormContext } from 'react-hook-form';
+export { FormProvider } from 'react-hook-form';
+/**
+ * Hook to create a standalone form instance
+ *
+ * Use this when you want to manage form state without the Form component wrapper.
+ *
+ * @example
+ * ```tsx
+ * const schema = z.object({ name: z.string() });
+ *
+ * function MyForm() {
+ *   const form = useForm({ schema });
+ *
+ *   return (
+ *     <FormProvider {...form}>
+ *       <FormField control={form.control} name="name" />
+ *     </FormProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function useForm<TFieldValues extends FieldValues>(options: {
+    schema?: FormSchema<TFieldValues>;
+} & Omit<UseFormProps<TFieldValues>, 'resolver'>): UseFormReturn<TFieldValues, any, TFieldValues>;
+//# sourceMappingURL=Form.d.ts.map

package/dist/form/Form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Form.d.ts","sourceRoot":"","sources":["../../src/form/Form.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,YAAY,EAElB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,KAAK,UAAU,CAAC,YAAY,SAAS,WAAW,IAAI,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;AAQnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,SAAS,CAAC,YAAY,SAAS,WAAW,CAAE,SAAQ,IAAI,CACvE,KAAK,CAAC,kBAAkB,CAAC,eAAe,CAAC,EACzC,UAAU,GAAG,UAAU,CACxB;IACC,gCAAgC;IAChC,MAAM,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC;IAClC,8BAA8B;IAC9B,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACtC,oCAAoC;IACpC,WAAW,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,CAAC;IAC3D,qCAAqC;IACrC,QAAQ,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,YAAY,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC;CAClE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,YAAY,SAAS,WAAW,EAAE,EACrD,MAAM,EACN,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,SAAS,EACT,GAAG,KAAK,EACT,EAAE,SAAS,CAAC,YAAY,CAAC,2CAezB;AAED;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,OAAO,CAAC,YAAY,SAAS,WAAW,EACtD,OAAO,EAAE;IACP,MAAM,CAAC,EAAE,UAAU,CAAC,YAAY,CAAC,CAAC;CACnC,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,kDAOjD"}

package/dist/form/FormDescription.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+/**
+ * FormDescription component props
+ */
+export type FormDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+/**
+ * FormDescription component - Displays helper text for form fields
+ *
+ * Provides additional context or instructions for form inputs.
+ * Accessible via aria-describedby on the form control.
+ *
+ * @example
+ * ```tsx
+ * <FormField
+ *   control={form.control}
+ *   name="password"
+ *   render={({ field }) => (
+ *     <FormItem>
+ *       <FormLabel>Password</FormLabel>
+ *       <FormControl>
+ *         <Input type="password" {...field} />
+ *       </FormControl>
+ *       <FormDescription>
+ *         Must be at least 8 characters with 1 uppercase letter and 1 number
+ *       </FormDescription>
+ *       <FormMessage />
+ *     </FormItem>
+ *   )}
+ * />
+ * ```
+ */
+export declare function FormDescription({ ref, className, ...props }: FormDescriptionProps & {
+    ref?: React.Ref<HTMLParagraphElement>;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FormDescription.d.ts.map

package/dist/form/FormDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormDescription.d.ts","sourceRoot":"","sources":["../../src/form/FormDescription.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,KAAK,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAAC,EAC9B,GAAG,EACH,SAAS,EACT,GAAG,KAAK,EACT,EAAE,oBAAoB,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAA;CAAE,2CAWlE"}

package/dist/form/FormField.d.ts

@@ -0,0 +1,100 @@
+import { ControllerProps, FieldPath, FieldValues } from 'react-hook-form';
+import * as React from 'react';
+/**
+ * Hook to access form field context
+ *
+ * Provides access to field name for nested components like FormLabel, FormMessage, etc.
+ *
+ * @example
+ * ```tsx
+ * function CustomInput() {
+ *   const { name } = useFormField();
+ *   return <input name={name} />;
+ * }
+ * ```
+ */
+export declare function useFormField(): {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import('react-hook-form').FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+/**
+ * FormField component props
+ */
+export type FormFieldProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = ControllerProps<TFieldValues, TName>;
+/**
+ * FormField component - Wrapper for form inputs with React Hook Form integration
+ *
+ * Uses React Hook Form's Controller component to manage field state.
+ * Provides context for child components (FormLabel, FormMessage, etc.).
+ *
+ * @example
+ * ```tsx
+ * <FormField
+ *   control={form.control}
+ *   name="email"
+ *   render={({ field }) => (
+ *     <FormItem>
+ *       <FormLabel>Email</FormLabel>
+ *       <FormControl>
+ *         <Input type="email" {...field} />
+ *       </FormControl>
+ *       <FormDescription>Enter your email address</FormDescription>
+ *       <FormMessage />
+ *     </FormItem>
+ *   )}
+ * />
+ * ```
+ */
+export declare function FormField<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: FormFieldProps<TFieldValues, TName>): import("react/jsx-runtime").JSX.Element;
+/**
+ * FormItem component props
+ */
+export type FormItemProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * FormItem component - Container for form field components
+ *
+ * Provides spacing and layout for form fields.
+ * Generates unique IDs for accessibility attributes.
+ *
+ * @example
+ * ```tsx
+ * <FormItem>
+ *   <FormLabel>Username</FormLabel>
+ *   <FormControl>
+ *     <Input />
+ *   </FormControl>
+ *   <FormMessage />
+ * </FormItem>
+ * ```
+ */
+export declare function FormItem({ ref, className, ...props }: FormItemProps & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * FormControl component props
+ */
+export type FormControlProps = React.HTMLAttributes<HTMLDivElement>;
+/**
+ * FormControl component - Wrapper for form input elements
+ *
+ * Connects input elements with form field state and accessibility attributes.
+ *
+ * @example
+ * ```tsx
+ * <FormControl>
+ *   <Input type="email" placeholder="you@example.com" />
+ * </FormControl>
+ * ```
+ */
+export declare function FormControl({ ref, ...props }: FormControlProps & {
+    ref?: React.Ref<HTMLDivElement>;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FormField.d.ts.map

package/dist/form/FormField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormField.d.ts","sourceRoot":"","sources":["../../src/form/FormField.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAezB;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY;;;;;;;;;;;EAqB3B;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,CACxB,YAAY,SAAS,WAAW,GAAG,WAAW,EAC9C,KAAK,SAAS,SAAS,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC,YAAY,CAAC,IAC7D,eAAe,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CACvB,YAAY,SAAS,WAAW,GAAG,WAAW,EAC9C,KAAK,SAAS,SAAS,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC,YAAY,CAAC,EAC/D,EAAE,GAAG,KAAK,EAAE,EAAE,cAAc,CAAC,YAAY,EAAE,KAAK,CAAC,2CAMlD;AAWD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,SAAS,EACT,GAAG,KAAK,EACT,EAAE,aAAa,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;CAAE,2CAQrD;AACD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,EAC1B,GAAG,EACH,GAAG,KAAK,EACT,EAAE,gBAAgB,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;CAAE,2CAYxD"}

package/dist/form/FormLabel.d.ts

@@ -0,0 +1,45 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+import * as LabelPrimitive from '@radix-ui/react-label';
+/**
+ * Label variants for different states and styles
+ */
+declare const labelVariants: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+/**
+ * FormLabel component props
+ */
+export interface FormLabelProps extends React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>, VariantProps<typeof labelVariants> {
+    /** Whether the field is required. Renders a red asterisk. */
+    required?: boolean;
+    /** Whether the field is optional. Renders muted "(optional)" suffix. Ignored if `required`. */
+    optional?: boolean;
+}
+/**
+ * FormLabel component - Accessible label for form fields
+ *
+ * Uses Radix UI Label primitive for accessibility.
+ * Automatically connects to form field via context.
+ * Shows error state and required indicator.
+ *
+ * @example
+ * ```tsx
+ * <FormField
+ *   control={form.control}
+ *   name="email"
+ *   render={({ field }) => (
+ *     <FormItem>
+ *       <FormLabel required>Email Address</FormLabel>
+ *       <FormControl>
+ *         <Input type="email" {...field} />
+ *       </FormControl>
+ *       <FormMessage />
+ *     </FormItem>
+ *   )}
+ * />
+ * ```
+ */
+export declare function FormLabel({ ref, className, required, optional, children, ...props }: FormLabelProps & {
+    ref?: React.Ref<React.ElementRef<typeof LabelPrimitive.Root>>;
+}): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=FormLabel.d.ts.map

package/dist/form/FormLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormLabel.d.ts","sourceRoot":"","sources":["../../src/form/FormLabel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,cAAc,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAIlE;;GAEG;AACH,QAAA,MAAM,aAAa,oFAElB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,cACf,SACE,KAAK,CAAC,wBAAwB,CAAC,OAAO,cAAc,CAAC,IAAI,CAAC,EAC1D,YAAY,CAAC,OAAO,aAAa,CAAC;IACpC,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+FAA+F;IAC/F,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,EACxB,GAAG,EACH,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,cAAc,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,CAAA;CAAE,2CAqBpF"}

package/dist/form/FormMessage.d.ts

@@ -0,0 +1,37 @@
+import * as React from 'react';
+/**
+ * FormMessage component props
+ */
+export type FormMessageProps = React.HTMLAttributes<HTMLParagraphElement>;
+/**
+ * FormMessage component - Displays error messages for form fields
+ *
+ * Automatically shows validation errors from React Hook Form.
+ * Accessible with proper ARIA attributes for screen readers.
+ *
+ * @example
+ * ```tsx
+ * <FormField
+ *   control={form.control}
+ *   name="email"
+ *   render={({ field }) => (
+ *     <FormItem>
+ *       <FormLabel>Email</FormLabel>
+ *       <FormControl>
+ *         <Input type="email" {...field} />
+ *       </FormControl>
+ *       <FormMessage />
+ *     </FormItem>
+ *   )}
+ * />
+ * ```
+ *
+ * @example Custom error message
+ * ```tsx
+ * <FormMessage>Custom validation message</FormMessage>
+ * ```
+ */
+export declare function FormMessage({ ref, className, children, ...props }: FormMessageProps & {
+    ref?: React.Ref<HTMLParagraphElement>;
+}): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=FormMessage.d.ts.map

package/dist/form/FormMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormMessage.d.ts","sourceRoot":"","sources":["../../src/form/FormMessage.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,EAC1B,GAAG,EACH,SAAS,EACT,QAAQ,EACR,GAAG,KAAK,EACT,EAAE,gBAAgB,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAA;CAAE,kDAoB9D"}

package/dist/form/FormSection.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+export interface FormSectionProps {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    actions?: React.ReactNode;
+    collapsible?: boolean;
+    defaultOpen?: boolean;
+    className?: string;
+    contentClassName?: string;
+    children: React.ReactNode;
+}
+/**
+ * Canonical container for a group of related form fields.
+ * `collapsible` opens by default; use OptionalFields from fe-libs/ui for
+ * Advanced-class fields (closed by default + single-per-page convention).
+ */
+export declare function FormSection({ title, description, actions, collapsible, defaultOpen, className, contentClassName, children, }: FormSectionProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FormSection.d.ts.map

package/dist/form/FormSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FormSection.d.ts","sourceRoot":"","sources":["../../src/form/FormSection.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B,OAAO,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAC1B,KAAK,EACL,WAAW,EACX,OAAO,EACP,WAAmB,EACnB,WAAkB,EAClB,SAAS,EACT,gBAAgB,EAChB,QAAQ,GACT,EAAE,gBAAgB,2CAwElB"}

package/dist/form/Input.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+/**
+ * Input component props
+ */
+export type InputProps = React.InputHTMLAttributes<HTMLInputElement>;
+/**
+ * Input component - Styled text input field
+ *
+ * A flexible input component with consistent styling using semantic tokens.
+ * Supports all native HTML input attributes including type, placeholder, disabled, etc.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <Input type="text" placeholder="Enter your name" />
+ * ```
+ *
+ * @example With React Hook Form
+ * ```tsx
+ * <FormField
+ *   control={form.control}
+ *   name="email"
+ *   render={({ field }) => (
+ *     <FormItem>
+ *       <FormLabel>Email</FormLabel>
+ *       <FormControl>
+ *         <Input type="email" placeholder="you@example.com" {...field} />
+ *       </FormControl>
+ *       <FormMessage />
+ *     </FormItem>
+ *   )}
+ * />
+ * ```
+ *
+ * @example Different input types
+ * ```tsx
+ * <Input type="password" placeholder="Enter password" />
+ * <Input type="number" min={0} max={100} />
+ * <Input type="date" />
+ * <Input type="file" accept="image/*" />
+ * ```
+ */
+export declare function Input({ ref, className, type, ...props }: InputProps & {
+    ref?: React.Ref<HTMLInputElement>;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Input.d.ts.map

package/dist/form/Input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.d.ts","sourceRoot":"","sources":["../../src/form/Input.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,KAAK,CAAC,EACpB,GAAG,EACH,SAAS,EACT,IAAI,EACJ,GAAG,KAAK,EACT,EAAE,UAAU,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAA;CAAE,2CAiBpD"}

package/dist/form/Radio.d.ts

@@ -0,0 +1,109 @@
+import * as React from 'react';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+/**
+ * RadioGroup component - Container for radio button options
+ */
+declare function RadioGroup({ ref, className, ...props }: React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root> & {
+    ref?: React.Ref<React.ElementRef<typeof RadioGroupPrimitive.Root>>;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace RadioGroup {
+    var displayName: string | undefined;
+}
+/**
+ * RadioGroupItem component props
+ */
+export type RadioGroupItemProps = React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>;
+/**
+ * RadioGroupItem component - Individual radio button
+ *
+ * A styled radio button component with proper accessibility features.
+ * Uses Radix UI RadioGroup primitive for robust functionality.
+ *
+ * @example Basic usage
+ * ```tsx
+ * <RadioGroup defaultValue="option1">
+ *   <div className="flex items-center space-x-2">
+ *     <RadioGroupItem value="option1" id="option1" />
+ *     <label htmlFor="option1">Option 1</label>
+ *   </div>
+ *   <div className="flex items-center space-x-2">
+ *     <RadioGroupItem value="option2" id="option2" />
+ *     <label htmlFor="option2">Option 2</label>
+ *   </div>
+ * </RadioGroup>
+ * ```
+ *
+ * @example With React Hook Form
+ * ```tsx
+ * <FormField
+ *   control={form.control}
+ *   name="type"
+ *   render={({ field }) => (
+ *     <FormItem className="space-y-3">
+ *       <FormLabel>Notification Type</FormLabel>
+ *       <FormControl>
+ *         <RadioGroup
+ *           onValueChange={field.onChange}
+ *           defaultValue={field.value}
+ *           className="flex flex-col space-y-1"
+ *         >
+ *           <FormItem className="flex items-center space-x-3 space-y-0">
+ *             <FormControl>
+ *               <RadioGroupItem value="all" />
+ *             </FormControl>
+ *             <FormLabel className="font-normal">
+ *               All new messages
+ *             </FormLabel>
+ *           </FormItem>
+ *           <FormItem className="flex items-center space-x-3 space-y-0">
+ *             <FormControl>
+ *               <RadioGroupItem value="mentions" />
+ *             </FormControl>
+ *             <FormLabel className="font-normal">
+ *               Direct messages and mentions
+ *             </FormLabel>
+ *           </FormItem>
+ *           <FormItem className="flex items-center space-x-3 space-y-0">
+ *             <FormControl>
+ *               <RadioGroupItem value="none" />
+ *             </FormControl>
+ *             <FormLabel className="font-normal">
+ *               Nothing
+ *             </FormLabel>
+ *           </FormItem>
+ *         </RadioGroup>
+ *       </FormControl>
+ *       <FormMessage />
+ *     </FormItem>
+ *   )}
+ * />
+ * ```
+ *
+ * @example Controlled radio group
+ * ```tsx
+ * const [value, setValue] = useState('option1');
+ *
+ * <RadioGroup value={value} onValueChange={setValue}>
+ *   <div className="flex items-center space-x-2">
+ *     <RadioGroupItem value="option1" id="r1" />
+ *     <label htmlFor="r1">Default</label>
+ *   </div>
+ *   <div className="flex items-center space-x-2">
+ *     <RadioGroupItem value="option2" id="r2" />
+ *     <label htmlFor="r2">Comfortable</label>
+ *   </div>
+ *   <div className="flex items-center space-x-2">
+ *     <RadioGroupItem value="option3" id="r3" />
+ *     <label htmlFor="r3">Compact</label>
+ *   </div>
+ * </RadioGroup>
+ * ```
+ */
+declare function RadioGroupItem({ ref, className, ...props }: RadioGroupItemProps & {
+    ref?: React.Ref<React.ElementRef<typeof RadioGroupPrimitive.Item>>;
+}): import("react/jsx-runtime").JSX.Element;
+declare namespace RadioGroupItem {
+    var displayName: string | undefined;
+}
+export { RadioGroup, RadioGroupItem };
+//# sourceMappingURL=Radio.d.ts.map

package/dist/form/Radio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Radio.d.ts","sourceRoot":"","sources":["../../src/form/Radio.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,mBAAmB,MAAM,6BAA6B,CAAC;AAInE;;GAEG;AACH,iBAAS,UAAU,CAAC,EAClB,GAAG,EACH,SAAS,EACT,GAAG,KAAK,EACT,EAAE,KAAK,CAAC,wBAAwB,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC,GAAG;IACnE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC;CACpE,2CAEA;kBARQ,UAAU;;;AAWnB;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,wBAAwB,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AACH,iBAAS,cAAc,CAAC,EACtB,GAAG,EACH,SAAS,EACT,GAAG,KAAK,EACT,EAAE,mBAAmB,GAAG;IAAE,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAA;CAAE,2CAiB9F;kBArBQ,cAAc;;;AAwBvB,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC"}