@raintonic/formaui 0.2.0

package/types/raintonic-formaui-components-password-input.d.ts

@@ -0,0 +1,111 @@
+import * as _angular_core from '@angular/core';
+import { DoCheck, OnDestroy, WritableSignal, Signal, ElementRef } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { FuiFormFieldControl, ErrorStateMatcher } from '@raintonic/formaui/core';
+
+type PasswordStrength = 'weak' | 'fair' | 'good' | 'strong';
+interface PasswordStrengthConfig {
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSpecial?: boolean;
+}
+declare const DEFAULT_STRENGTH_CONFIG: PasswordStrengthConfig;
+
+/**
+ * # FuiPasswordInputComponent
+ *
+ * A password input component with visibility toggle and optional strength meter.
+ * Integrates with fui-form-field and Angular Forms.
+ *
+ * ## Features
+ * - Password visibility toggle
+ * - Optional password strength meter
+ * - Full Reactive Forms integration (ControlValueAccessor)
+ * - FuiFormFieldControl integration for fui-form-field
+ * - Error state handling
+ * - Accessibility (ARIA)
+ *
+ * ## Usage
+ *
+ * ### Basic Password Input
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Password</fui-label>
+ *   <fui-password-input formControlName="password"></fui-password-input>
+ * </fui-form-field>
+ * ```
+ *
+ * ### With Strength Meter
+ * ```html
+ * <fui-form-field>
+ *   <fui-label>Password</fui-label>
+ *   <fui-password-input
+ *     formControlName="password"
+ *     [showStrengthMeter]="true"
+ *   ></fui-password-input>
+ * </fui-form-field>
+ * ```
+ */
+declare class FuiPasswordInputComponent implements ControlValueAccessor, FuiFormFieldControl<string>, DoCheck, OnDestroy {
+    static nextId: number;
+    readonly controlType = "fui-password-input";
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showStrengthMeter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly strengthConfig: _angular_core.InputSignal<PasswordStrengthConfig>;
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | null>;
+    readonly _passwordVisible: WritableSignal<boolean>;
+    readonly _value: WritableSignal<string>;
+    private readonly _focused;
+    readonly focused: Signal<boolean>;
+    private readonly _disabled;
+    private readonly _ngControlDisabled;
+    private readonly _errorState;
+    readonly errorState: Signal<boolean>;
+    private readonly _required;
+    readonly required: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly _inputType: Signal<string>;
+    readonly value: Signal<string>;
+    readonly empty: Signal<boolean>;
+    readonly _strength: Signal<PasswordStrength>;
+    readonly _strengthPercent: Signal<number>;
+    readonly stateChanges: Subject<void>;
+    private _uid;
+    readonly id: string;
+    _ariaDescribedby: string | null;
+    private _parentForm;
+    private _parentFormGroup;
+    private _defaultErrorStateMatcher;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    readonly inputElement: Signal<ElementRef<HTMLInputElement> | undefined>;
+    private _onChange;
+    private _onTouched;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onContainerClick(_event: MouseEvent): void;
+    setDescribedByIds(ids: string[]): void;
+    _onInput(event: Event): void;
+    _onFocus(): void;
+    _onBlur(): void;
+    toggleVisibility(): void;
+    focus(): void;
+    blur(): void;
+    _calculateStrength(password: string): PasswordStrength;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiPasswordInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiPasswordInputComponent, "fui-password-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "showStrengthMeter": { "alias": "showStrengthMeter"; "required": false; "isSignal": true; }; "strengthConfig": { "alias": "strengthConfig"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DEFAULT_STRENGTH_CONFIG, FuiPasswordInputComponent };
+export type { PasswordStrength, PasswordStrengthConfig };
+//# sourceMappingURL=raintonic-formaui-components-password-input.d.ts.map

package/types/raintonic-formaui-components-password-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-password-input.d.ts","sources":["../../../lib/components/password-input/password-input.types.ts","../../../lib/components/password-input/password-input.component.ts"],"mappings":";;;;;;AAAM,KAAM,gBAAgB;UAEX,sBAAsB;;;;;;AAMtC;AAED,cAAa,uBAAuB,EAAE,sBAMrC;;ACUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCG;AACH,cA4Ba,yBACX,YAAW,oBAAoB,EAAE,mBAAmB,UAAU,OAAO,EAAE,SAAS;;;0BAO5D,aAAA,CAAA,WAAA;4BACE,aAAA,CAAA,wBAAA;uBAIL,aAAA,CAAA,wBAAA;gCAGS,aAAA,CAAA,wBAAA;6BAGH,aAAA,CAAA,WAAA,CAAA,sBAAA;gCACG,aAAA,CAAA,WAAA,CAAA,iBAAA;AAG1B,+BAA2B,cAAc;AACzC,qBAAiB,cAAc;AAC/B;AACA,sBAAkB,MAAM;AACxB;AACA;AACA;AACA,yBAAqB,MAAM;AAC3B;AACA,uBAAmB,MAAM;AAGzB,uBAAmB,MAAM;AAGzB,yBAAqB,MAAM;AAC3B,oBAAgB,MAAM;AACtB,oBAAgB,MAAM;AAKtB,wBAAoB,MAAM,CAAC,gBAAgB;AAI3C,+BAA2B,MAAM;2BAgBZ,OAAA;;;AAGrB;;;;AAMA;AACA,qBAAiB,SAAS;AAK1B,2BAAuB,MAAM,CAAC,UAAU,CAAC,gBAAgB;;;;AAwCzD;AAgBA;AAKA;;AAeA;AAIA;AAKA,6BAAyB,UAAU;AAMnC;AAKA,oBAAgB,KAAK;AAUrB;AAOA;AAQA;AAKA;AAIA;AAKA,0CAAsC,gBAAgB;oDAvN3C,yBAAyB;sDAAzB,yBAAyB;AA2QrC;;;;","names":[]}

package/types/raintonic-formaui-components-popover.d.ts

@@ -0,0 +1,131 @@
+import * as _angular_core from '@angular/core';
+import { Signal, OnDestroy, TemplateRef, WritableSignal } from '@angular/core';
+
+type PopoverTriggerMode = 'click' | 'hover' | 'focus' | 'manual';
+type PopoverPosition = 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end' | 'right-start' | 'right-end';
+declare const POPOVER_POSITIONS: readonly ["top", "bottom", "left", "right", "top-start", "top-end", "bottom-start", "bottom-end", "left-start", "left-end", "right-start", "right-end"];
+declare const POPOVER_TRIGGER_MODES: readonly ["click", "hover", "focus", "manual"];
+
+/**
+ * # FuiPopoverComponent
+ *
+ * Internal popover container component rendered inside the overlay.
+ * Provides a styled panel with optional arrow indicator.
+ *
+ * ## Usage
+ * This component is not used directly. Use the `[fuiPopoverTrigger]` directive instead.
+ */
+declare class FuiPopoverComponent {
+    /** Whether to show the arrow indicator */
+    readonly hasArrow: _angular_core.InputSignal<boolean>;
+    /** Position of the popover relative to the trigger element, used for arrow calculation */
+    readonly position: _angular_core.InputSignal<PopoverPosition>;
+    /** Computed CSS classes for the popover */
+    readonly computedClasses: Signal<string>;
+    /** Computed arrow classes based on position */
+    readonly arrowClasses: Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiPopoverComponent, "fui-popover", never, { "hasArrow": { "alias": "hasArrow"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * # PopoverTrigger Directive
+ *
+ * A directive that triggers a popover overlay anchored to the host element.
+ * Supports click, hover, focus, and manual trigger modes with configurable
+ * positioning, delays, and arrow indicators.
+ *
+ * ## Usage
+ *
+ * ### Basic Click Popover
+ * ```html
+ * <ng-template #popoverContent>
+ *   <p>Popover content here</p>
+ * </ng-template>
+ *
+ * <button [fuiPopoverTrigger]="popoverContent">Open Popover</button>
+ * ```
+ *
+ * ### Hover with Position
+ * ```html
+ * <button [fuiPopoverTrigger]="popoverContent"
+ *         fuiPopoverTriggerOn="hover"
+ *         fuiPopoverPosition="top">
+ *   Hover Me
+ * </button>
+ * ```
+ *
+ * ### Manual Control
+ * ```html
+ * <button [fuiPopoverTrigger]="popoverContent"
+ *         fuiPopoverTriggerOn="manual"
+ *         [fuiPopoverOpen]="isOpen">
+ *   Manual Popover
+ * </button>
+ * ```
+ */
+declare class FuiPopoverTriggerDirective implements OnDestroy {
+    /** Template ref for the popover content */
+    readonly fuiPopoverTrigger: _angular_core.InputSignal<TemplateRef<unknown>>;
+    /** Position of the popover relative to the trigger element */
+    readonly fuiPopoverPosition: _angular_core.InputSignalWithTransform<PopoverPosition, string>;
+    /** Trigger mode for showing/hiding the popover */
+    readonly fuiPopoverTriggerOn: _angular_core.InputSignalWithTransform<PopoverTriggerMode, string>;
+    /** Delay before showing the popover (in milliseconds) */
+    readonly fuiPopoverShowDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Delay before hiding the popover (in milliseconds) */
+    readonly fuiPopoverHideDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Whether to show the arrow indicator */
+    readonly fuiPopoverHasArrow: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether to close on outside click */
+    readonly fuiPopoverCloseOnOutsideClick: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the popover trigger is disabled */
+    readonly fuiPopoverDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Manual control for showing/hiding the popover (only works with trigger="manual") */
+    readonly fuiPopoverOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emits when the popover is opened */
+    readonly fuiPopoverOpened: _angular_core.OutputEmitterRef<void>;
+    /** Emits when the popover is closed */
+    readonly fuiPopoverClosed: _angular_core.OutputEmitterRef<void>;
+    readonly _isOpen: WritableSignal<boolean>;
+    private _overlayRef;
+    private _embeddedViewRef;
+    private _showTimeout;
+    private _hideTimeout;
+    private _subscriptions;
+    private readonly _elementRef;
+    private readonly _overlayService;
+    constructor();
+    ngOnDestroy(): void;
+    onHostClick(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocus(): void;
+    onBlur(): void;
+    onKeydown(event: KeyboardEvent): void;
+    /** Programmatically show the popover */
+    show(): void;
+    /** Programmatically hide the popover */
+    hide(): void;
+    /** Toggle popover visibility */
+    toggle(): void;
+    private _scheduleShow;
+    private _scheduleHide;
+    private _previouslyFocusedElement;
+    private _showPopover;
+    private _hidePopover;
+    private _focusFirstInOverlay;
+    private _createPopover;
+    private _getPositions;
+    private _destroyPopover;
+    private _clearTimeouts;
+    private readonly _onDocumentClick;
+    private readonly _onOverlayMouseEnter;
+    private readonly _onOverlayMouseLeave;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiPopoverTriggerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FuiPopoverTriggerDirective, "[fuiPopoverTrigger]", never, { "fuiPopoverTrigger": { "alias": "fuiPopoverTrigger"; "required": true; "isSignal": true; }; "fuiPopoverPosition": { "alias": "fuiPopoverPosition"; "required": false; "isSignal": true; }; "fuiPopoverTriggerOn": { "alias": "fuiPopoverTriggerOn"; "required": false; "isSignal": true; }; "fuiPopoverShowDelay": { "alias": "fuiPopoverShowDelay"; "required": false; "isSignal": true; }; "fuiPopoverHideDelay": { "alias": "fuiPopoverHideDelay"; "required": false; "isSignal": true; }; "fuiPopoverHasArrow": { "alias": "fuiPopoverHasArrow"; "required": false; "isSignal": true; }; "fuiPopoverCloseOnOutsideClick": { "alias": "fuiPopoverCloseOnOutsideClick"; "required": false; "isSignal": true; }; "fuiPopoverDisabled": { "alias": "fuiPopoverDisabled"; "required": false; "isSignal": true; }; "fuiPopoverOpen": { "alias": "fuiPopoverOpen"; "required": false; "isSignal": true; }; }, { "fuiPopoverOpened": "fuiPopoverOpened"; "fuiPopoverClosed": "fuiPopoverClosed"; }, never, never, true, never>;
+}
+
+export { FuiPopoverComponent, FuiPopoverTriggerDirective, POPOVER_POSITIONS, POPOVER_TRIGGER_MODES };
+export type { PopoverPosition, PopoverTriggerMode };
+//# sourceMappingURL=raintonic-formaui-components-popover.d.ts.map

package/types/raintonic-formaui-components-popover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-popover.d.ts","sources":["../../../lib/components/popover/popover.types.ts","../../../lib/components/popover/popover.component.ts","../../../lib/components/popover/popover-trigger.directive.ts"],"mappings":";;;AAAM,KAAM,kBAAkB;AACxB,KAAM,eAAe;AAc3B,cAAa,iBAAiB;AAe9B,cAAa,qBAAqB;;AC3BlC;;;;;;;;AAQG;AACH,cAaa,mBAAmB;;uBAEb,aAAA,CAAA,WAAA;;uBAGA,aAAA,CAAA,WAAA,CAAA,eAAA;;AAGjB,8BAA0B,MAAM;;AAWhC,2BAAuB,MAAM;oDAnBlB,mBAAmB;sDAAnB,mBAAmB;AAmC/B;;ACxCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;AACH,cAQa,0BAA2B,YAAW,SAAS;;gCAEhC,aAAA,CAAA,WAAA,CAAA,WAAA;;iCAGC,aAAA,CAAA,wBAAA,CAAA,eAAA;;kCAKC,aAAA,CAAA,wBAAA,CAAA,kBAAA;;kCAKA,aAAA,CAAA,wBAAA;;kCAGA,aAAA,CAAA,wBAAA;;iCAGD,aAAA,CAAA,wBAAA;;4CAGW,aAAA,CAAA,wBAAA;;iCAGX,aAAA,CAAA,wBAAA;;6BAGJ,aAAA,CAAA,wBAAA;;+BAGE,aAAA,CAAA,gBAAA;;+BAGA,aAAA,CAAA,gBAAA;AAGzB,sBAAkB,cAAc;;;;;;AAQhC;AACA;;AAsBA;AAMA;AAWA;AAOA;AAOA;AAOA;AAOA,qBAAiB,aAAa;;AAQ9B;;AAOA;;AAKA;AAQA;AAYA;;AAcA;AAyBA;AAiBA;AAaA;AAsCA;AAwDA;AAoBA;AAWA;AAUA;AAIA;oDA3WW,0BAA0B;sDAA1B,0BAA0B;AAgXtC;;;;","names":[]}

package/types/raintonic-formaui-components-progressbar.d.ts

@@ -0,0 +1,111 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * Progress bar mode types (compatible with mat-progress-bar)
+ */
+type ProgressBarMode = 'determinate' | 'indeterminate' | 'buffer' | 'query';
+/**
+ * Progress bar color variants
+ */
+type ProgressBarColor = 'primary' | 'accent' | 'warn' | 'success' | 'info';
+/**
+ * # FuiProgressbar Component
+ *
+ * A progress bar component compatible with Angular Material's mat-progress-bar interface.
+ *
+ * ## Features
+ * - Multiple modes: determinate, indeterminate, buffer, query
+ * - Color variants: primary, accent, warn, success, info
+ * - Accessible with ARIA attributes
+ * - Smooth animations
+ *
+ * ## Usage
+ *
+ * ### Determinate Progress
+ * ```html
+ * <fui-progressbar [value]="50"></fui-progressbar>
+ * ```
+ *
+ * ### Indeterminate Progress
+ * ```html
+ * <fui-progressbar mode="indeterminate"></fui-progressbar>
+ * ```
+ *
+ * ### Buffer Progress
+ * ```html
+ * <fui-progressbar mode="buffer" [value]="50" [bufferValue]="75"></fui-progressbar>
+ * ```
+ *
+ * ### Query Progress
+ * ```html
+ * <fui-progressbar mode="query"></fui-progressbar>
+ * ```
+ *
+ * ### Color Variants
+ * ```html
+ * <fui-progressbar [value]="50" color="success"></fui-progressbar>
+ * ```
+ */
+declare class FuiProgressbarComponent {
+    /**
+     * Progress bar mode (compatible with mat-progress-bar)
+     * - determinate: Shows a specific progress value
+     * - indeterminate: Shows an animation for unknown progress
+     * - buffer: Shows progress with a buffer indicator
+     * - query: Shows a query animation (reverse indeterminate)
+     */
+    readonly mode: _angular_core.InputSignal<ProgressBarMode>;
+    /**
+     * Progress value (0-100)
+     */
+    readonly value: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Buffer value for buffer mode (0-100)
+     */
+    readonly bufferValue: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Color variant
+     */
+    readonly color: _angular_core.InputSignal<ProgressBarColor>;
+    /**
+     * ARIA label for accessibility.
+     * When neither aria-label nor aria-labelledby is provided, a default label
+     * is computed based on the mode (e.g. "Loading" for indeterminate/query).
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * ARIA labelledby for accessibility
+     */
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    /**
+     * Effective aria-label: uses the explicit input, or falls back to a
+     * default when no aria-labelledby is provided either.
+     */
+    readonly effectiveAriaLabel: _angular_core.Signal<string | null>;
+    /**
+     * Clamped progress value (0-100)
+     */
+    readonly clampedValue: _angular_core.Signal<number>;
+    /**
+     * Clamped buffer value (0-100)
+     */
+    readonly clampedBufferValue: _angular_core.Signal<number>;
+    /**
+     * Transform for the primary progress bar
+     */
+    readonly primaryTransform: _angular_core.Signal<string>;
+    /**
+     * Transform for the buffer bar
+     */
+    readonly bufferTransform: _angular_core.Signal<string>;
+    /**
+     * Clamps a value between 0 and 100
+     */
+    private _clamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiProgressbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiProgressbarComponent, "fui-progressbar", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "bufferValue": { "alias": "bufferValue"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FuiProgressbarComponent };
+export type { ProgressBarColor, ProgressBarMode };
+//# sourceMappingURL=raintonic-formaui-components-progressbar.d.ts.map

package/types/raintonic-formaui-components-progressbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-progressbar.d.ts","sources":["../../../lib/components/progressbar/progressbar.component.ts"],"mappings":";;AAEA;;AAEG;AACG,KAAM,eAAe;AAE3B;;AAEG;AACG,KAAM,gBAAgB;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCG;AACH,cA2Ba,uBAAuB;AAClC;;;;;;AAMG;mBACU,aAAA,CAAA,WAAA,CAAA,eAAA;AAEb;;AAEG;oBACW,aAAA,CAAA,wBAAA;AAId;;AAEG;0BACiB,aAAA,CAAA,wBAAA;AAIpB;;AAEG;oBACW,aAAA,CAAA,WAAA,CAAA,gBAAA;AAEd;;;;AAIG;wBACe,aAAA,CAAA,WAAA;AAElB;;AAEG;6BACoB,aAAA,CAAA,WAAA;AAEvB;;;AAGG;iCACwB,aAAA,CAAA,MAAA;AAW3B;;AAEG;2BACkB,aAAA,CAAA,MAAA;AAErB;;AAEG;iCACwB,aAAA,CAAA,MAAA;AAE3B;;AAEG;+BACsB,aAAA,CAAA,MAAA;AAKzB;;AAEG;8BACqB,aAAA,CAAA,MAAA;AAKxB;;AAEG;AACH;oDArFW,uBAAuB;sDAAvB,uBAAuB;AAwFnC;;;;","names":[]}

package/types/raintonic-formaui-components-radio.d.ts

@@ -0,0 +1,95 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, ElementRef, DoCheck, OnDestroy, OutputEmitterRef, Signal } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { ErrorStateMatcher } from '@raintonic/formaui/core';
+
+type FuiRadioOrientation = 'horizontal' | 'vertical';
+interface FuiRadioChange<T = unknown> {
+    source: unknown;
+    value: T;
+}
+interface FuiRadioGroupHost {
+    disabled(): boolean;
+    selectValue(value: unknown, source: unknown): void;
+    setFocused(focused: boolean): void;
+    selectAdjacentRadio(direction: 1 | -1): void;
+}
+declare const FUI_RADIO_GROUP: InjectionToken<FuiRadioGroupHost>;
+
+declare class FuiRadioButtonComponent {
+    static nextId: number;
+    readonly value: _angular_core.InputSignal<unknown>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly _checked: _angular_core.WritableSignal<boolean>;
+    readonly _disabled: _angular_core.WritableSignal<boolean>;
+    readonly _focused: _angular_core.WritableSignal<boolean>;
+    readonly _name: _angular_core.WritableSignal<string>;
+    readonly _tabIndex: _angular_core.WritableSignal<number>;
+    private _uid;
+    readonly id: string;
+    readonly inputId: string;
+    private _radioGroup;
+    readonly inputElement: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    readonly isDisabled: _angular_core.Signal<boolean>;
+    onInputChange(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    onKeydown(event: KeyboardEvent): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiRadioButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiRadioButtonComponent, "fui-radio-button", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class FuiRadioGroupComponent implements ControlValueAccessor, DoCheck, OnDestroy {
+    static nextId: number;
+    readonly controlType = "fui-radio-group";
+    readonly name: _angular_core.InputSignal<string>;
+    readonly orientation: _angular_core.InputSignal<FuiRadioOrientation>;
+    readonly disabledInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly ariaLabelledby: _angular_core.InputSignal<string | null>;
+    readonly errorStateMatcher: _angular_core.InputSignal<ErrorStateMatcher | null>;
+    readonly change: OutputEmitterRef<FuiRadioChange>;
+    readonly radioButtons: Signal<readonly FuiRadioButtonComponent[]>;
+    private readonly _value;
+    private readonly _focused;
+    private readonly _disabled;
+    private readonly _required;
+    private readonly _ngControlDisabled;
+    private readonly _errorState;
+    readonly value: Signal<unknown>;
+    readonly focused: Signal<boolean>;
+    readonly errorState: Signal<boolean>;
+    readonly required: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly stateChanges: Subject<void>;
+    private _uid;
+    readonly id: string;
+    private _parentForm;
+    private _parentFormGroup;
+    private _defaultErrorStateMatcher;
+    private readonly _ngControlRef;
+    get ngControl(): NgControl | null;
+    private _onChange;
+    private _onTouched;
+    private _formControlInitialized;
+    constructor();
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    selectValue(value: unknown, source: FuiRadioButtonComponent): void;
+    setFocused(focused: boolean): void;
+    selectAdjacentRadio(direction: 1 | -1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiRadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiRadioGroupComponent, "fui-radio-group", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "errorStateMatcher": { "alias": "errorStateMatcher"; "required": false; "isSignal": true; }; }, { "change": "change"; }, ["radioButtons"], ["*"], true, never>;
+}
+
+export { FUI_RADIO_GROUP, FuiRadioButtonComponent, FuiRadioGroupComponent };
+export type { FuiRadioChange, FuiRadioGroupHost, FuiRadioOrientation };
+//# sourceMappingURL=raintonic-formaui-components-radio.d.ts.map

package/types/raintonic-formaui-components-radio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-radio.d.ts","sources":["../../../lib/components/radio/radio.types.ts","../../../lib/components/radio/radio-button.component.ts","../../../lib/components/radio/radio-group.component.ts"],"mappings":";;;;;;KAEY,mBAAmB;AAEzB,UAAW,cAAc;;;AAG9B;UAEgB,iBAAiB;;;AAGhC;;AAED;AAED,cAAa,eAAe,EAAA,cAAA,CAAA,iBAAA;;ACF5B,cAgBa,uBAAuB;;oBAGpB,aAAA,CAAA,WAAA;4BACQ,aAAA,CAAA,wBAAA;wBAIJ,aAAA,CAAA,WAAA;6BACK,aAAA,CAAA,WAAA;uBAKN,aAAA,CAAA,cAAA;wBACC,aAAA,CAAA,cAAA;uBACD,aAAA,CAAA,cAAA;oBACH,aAAA,CAAA,cAAA;wBACI,aAAA,CAAA,cAAA;;;;;2BAQG,aAAA,CAAA,MAAA,CAAA,UAAA,CAAA,gBAAA;yBAEF,aAAA,CAAA,MAAA;AAInB,yBAAqB,KAAK;AAQ1B;AAKA;AAKA,qBAAiB,aAAa;AAgB9B;oDAlEW,uBAAuB;sDAAvB,uBAAuB;AAqEnC;;AC1ED,cA2Ba,sBAAuB,YAAW,oBAAoB,EAAE,OAAO,EAAE,SAAS;;;mBAKxE,aAAA,CAAA,WAAA;0BACO,aAAA,CAAA,WAAA,CAAA,mBAAA;4BACE,aAAA,CAAA,wBAAA;wBAIJ,aAAA,CAAA,WAAA;6BACK,aAAA,CAAA,WAAA;gCAGG,aAAA,CAAA,WAAA,CAAA,iBAAA;AAG1B,qBAAiB,gBAAgB,CAAC,cAAc;2BAG3B,MAAA,UAAA,uBAAA;AAGrB;AACA;AACA;AACA;AACA;AACA;AAEA,oBAAgB,MAAM;AACtB,sBAAkB,MAAM;yBACL,MAAA;AACnB,uBAAmB,MAAM;AACzB,uBAAmB,MAAM;2BAIJ,OAAA;;;;;;AAQrB;AACA,qBAAiB,SAAS;;;;;AAoD1B;AAgBA;AAKA;;AAUA;AAIA;wCAMoC,uBAAuB;AAQ3D;;oDArJW,sBAAsB;sDAAtB,sBAAsB;AA+KlC;;;;","names":[]}