@raintonic/formaui 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-avatar.d.ts","sources":["../../../lib/components/avatar/avatar.component.ts"],"mappings":";;;AAEM,KAAM,aAAa;AAEzB;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,cAQa,kBAAkB;mBAEhB,aAAA,CAAA,WAAA,UAAA,aAAA;oBACC,aAAA,CAAA,WAAA;kBACF,aAAA,CAAA,WAAA;wBAEM,aAAA,CAAA,WAAA;qBACH,aAAA,CAAA,WAAA;wBACG,aAAA,CAAA,WAAA;mBACL,aAAA,CAAA,WAAA;sBACG,aAAA,CAAA,WAAA;uBACC,aAAA,CAAA,WAAA;kBACL,aAAA,CAAA,WAAA;0BACQ,aAAA,CAAA,WAAA;AAGpB;AAGA,6BAAyB,MAAM;AAK/B,uBAAmB,MAAM;AAOzB,wBAAoB,MAAM;2BAMH,MAAM;AAK7B,sBAAkB,MAAM;AAQxB,wBAAoB,MAAM;AAI1B;oDAtDW,kBAAkB;sDAAlB,kBAAkB;AAyD9B;;;;","names":[]}

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

@@ -0,0 +1,47 @@
+import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
+
+type FuiBadgeSize = 'sm' | 'md' | 'lg';
+type FuiBadgeVariant = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'custom';
+declare const FUI_BADGE_SIZES: readonly FuiBadgeSize[];
+declare const FUI_BADGE_VARIANTS: readonly FuiBadgeVariant[];
+
+/**
+ * @component FuiBadgeComponent
+ * @selector fui-badge
+ * @description Displays a small label badge with optional icon and color variants.
+ * Supports custom colors with automatic text contrast calculation.
+ *
+ * @input label - (required) Text content of the badge.
+ * @input icon - Optional Phosphor icon name displayed before the label.
+ * @input customColor - Optional hex color that overrides the variant palette.
+ * @input size - Badge size: 'sm' | 'md' | 'lg'. Default 'md'.
+ * @input variant - Color variant: 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info'. Default 'primary'.
+ * @input ariaLabel - Accessible label override for screen readers.
+ *
+ * @example
+ * <fui-badge label="Active" variant="success" icon="check-circle"></fui-badge>
+ */
+declare class FuiBadgeComponent {
+    /** Pattern allowing hex, rgb/rgba, hsl/hsla, and CSS named colors */
+    private static readonly _SAFE_COLOR_PATTERN;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string | null>;
+    readonly customColor: _angular_core.InputSignal<string | null>;
+    readonly size: _angular_core.InputSignalWithTransform<FuiBadgeSize, string>;
+    readonly variant: _angular_core.InputSignalWithTransform<FuiBadgeVariant, string>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /** Validated custom color - returns null for invalid values to prevent CSS injection */
+    readonly sanitizedColor: Signal<string | null>;
+    readonly computedTextColor: Signal<string | null>;
+    readonly computedStyles: Signal<Record<string, string>>;
+    readonly computedClasses: Signal<string>;
+    readonly iconSize: Signal<'sm' | 'md' | 'lg'>;
+    private getRelativeLuminance;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiBadgeComponent, "fui-badge", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "customColor": { "alias": "customColor"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FUI_BADGE_SIZES, FUI_BADGE_VARIANTS, FuiBadgeComponent };
+export type { FuiBadgeSize, FuiBadgeVariant };
+//# sourceMappingURL=raintonic-formaui-components-badge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-badge.d.ts","sources":["../../../lib/components/badge/badge.types.ts","../../../lib/components/badge/badge.component.ts"],"mappings":";;;AAAM,KAAM,YAAY;KAEZ,eAAe;AAE3B,cAAa,eAAe,WAAW,YAAY;AAEnD,cAAa,kBAAkB,WAAW,eAAe;;ACFzD;;;;;;;;;;;;;;;AAeG;AACH,cAca,iBAAiB;;AAE5B;oBAEc,aAAA,CAAA,WAAA;mBAED,aAAA,CAAA,WAAA;0BAEO,aAAA,CAAA,WAAA;mBAEP,aAAA,CAAA,wBAAA,CAAA,YAAA;sBAIG,aAAA,CAAA,wBAAA,CAAA,eAAA;wBAIE,aAAA,CAAA,WAAA;;6BAGO,MAAM;gCAUH,MAAM;6BAOX,MAAA,CAAA,MAAA;AASvB,8BAA0B,MAAM;uBAWb,MAAM;AAMzB;oDAhEW,iBAAiB;sDAAjB,iBAAiB;AA0E7B;;;;","names":[]}

package/types/raintonic-formaui-components-big-menu.d.ts

@@ -0,0 +1,62 @@
+import * as _angular_core from '@angular/core';
+import { OnInit } from '@angular/core';
+
+interface BigMenuItem {
+    id: string;
+    label: string;
+    icon: string;
+    children: BigMenuChild[];
+}
+interface BigMenuChild {
+    id: string;
+    label: string;
+    icon: string;
+    isActive?: boolean;
+    link?: string;
+    value?: string;
+    badge?: number;
+}
+
+/**
+ * @component FuiBigMenuComponent
+ * @selector fui-big-menu
+ * @description A two-level navigation mega-menu. The primary column displays icon-based
+ * main menu items; hovering over or selecting a main item reveals a secondary flyout
+ * panel listing its children. Designed for application-level navigation alongside
+ * `fui-toolbar` and `fui-sidebar`.
+ *
+ * @input menu - (required) Array of `BigMenuItem` objects defining the menu structure
+ *
+ * @output itemMenuClick - Emits `{ item: BigMenuChild; event: MouseEvent }` when a child item is clicked
+ *
+ * @cssvar --fui-big-menu-width - Width of the primary icon column (default: 90px)
+ * @cssvar --fui-big-menu-bg - Background color of both menu panels
+ * @cssvar --fui-big-menu-border-color - Border color between panels and edge
+ * @cssvar --fui-big-menu-item-size - Width and height of primary menu item icons
+ * @cssvar --fui-big-menu-item-border-radius - Border radius of primary item icons
+ * @cssvar --fui-big-menu-secondary-width - Width of the secondary flyout panel (default: 228px)
+ * @cssvar --fui-big-menu-secondary-item-height - Height of each child item row
+ *
+ * @example
+ * <fui-big-menu [menu]="menuItems" (itemMenuClick)="onItemClick($event)"></fui-big-menu>
+ */
+declare class FuiBigMenuComponent implements OnInit {
+    menu: _angular_core.InputSignal<BigMenuItem[]>;
+    itemMenuClick: _angular_core.OutputEmitterRef<{
+        item: BigMenuChild;
+        event: MouseEvent;
+    }>;
+    selectedMainVoice: _angular_core.WritableSignal<BigMenuItem | null>;
+    selectedMainVoiceId: _angular_core.Signal<string | undefined>;
+    showSecondaryMenu: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    selectMainVoice(voice: BigMenuItem): void;
+    onMouseOver(): void;
+    onMouseLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiBigMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiBigMenuComponent, "fui-big-menu", never, { "menu": { "alias": "menu"; "required": true; "isSignal": true; }; }, { "itemMenuClick": "itemMenuClick"; }, never, ["[top-content]", "[bottom-content]"], true, never>;
+}
+
+export { FuiBigMenuComponent };
+export type { BigMenuChild, BigMenuItem };
+//# sourceMappingURL=raintonic-formaui-components-big-menu.d.ts.map

package/types/raintonic-formaui-components-big-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-big-menu.d.ts","sources":["../../../lib/components/big-menu/big-menu-item.interface.ts","../../../lib/components/big-menu/big-menu.component.ts"],"mappings":";;;UAAiB,WAAW;;;;cAIhB,YAAY;AACvB;UAEgB,YAAY;;;;;;;;AAQ5B;;ACVD;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACH,cAMa,mBAAoB,YAAW,MAAM;AAChD,UAAI,aAAA,CAAA,WAAA,CAAA,WAAA;mBAES,aAAA,CAAA,gBAAA;cAAkB,YAAY;eAAS,UAAU;AAAM;AACpE,uBAAiB,aAAA,CAAA,cAAA,CAAA,WAAA;AACjB,yBAAmB,aAAA,CAAA,MAAA;AACnB,uBAAiB,aAAA,CAAA,cAAA;AAEjB;AAIA,2BAAuB,WAAW;AAOlC;AAKA;oDAxBW,mBAAmB;sDAAnB,mBAAmB;AA2B/B;;;;","names":[]}

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

@@ -0,0 +1,26 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+declare class FuiBreadcrumbItemComponent {
+    readonly routerLink: _angular_core.InputSignal<string | unknown[] | null>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isLast: _angular_core.WritableSignal<boolean>;
+    readonly _separator: _angular_core.WritableSignal<string>;
+    readonly isLink: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiBreadcrumbItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiBreadcrumbItemComponent, "fui-breadcrumb-item", never, { "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*", "*"], true, never>;
+}
+
+declare class FuiBreadcrumbComponent {
+    readonly separator: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly items: _angular_core.Signal<readonly FuiBreadcrumbItemComponent[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiBreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FuiBreadcrumbComponent, "fui-breadcrumb", never, { "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+declare const FUI_BREADCRUMB: InjectionToken<unknown>;
+
+export { FUI_BREADCRUMB, FuiBreadcrumbComponent, FuiBreadcrumbItemComponent };
+//# sourceMappingURL=raintonic-formaui-components-breadcrumb.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-breadcrumb.d.ts","sources":["../../../lib/components/breadcrumb/breadcrumb-item.component.ts","../../../lib/components/breadcrumb/breadcrumb.component.ts","../../../lib/components/breadcrumb/breadcrumb.types.ts"],"mappings":";;;AAWA,cAea,0BAA0B;yBAClB,aAAA,CAAA,WAAA;uBACF,aAAA,CAAA,wBAAA;qBAGF,aAAA,CAAA,cAAA;yBACI,aAAA,CAAA,cAAA;qBAEJ,aAAA,CAAA,MAAA;oDARJ,0BAA0B;sDAA1B,0BAA0B;AAStC;;AC/BD,cAaa,sBAAsB;wBACf,aAAA,CAAA,WAAA;wBACA,aAAA,CAAA,WAAA;oBAEJ,aAAA,CAAA,MAAA,UAAA,0BAAA;;oDAJH,sBAAsB;sDAAtB,sBAAsB;AAelC;;AC9BD,cAAa,cAAc,EAAA,cAAA;;;;","names":[]}

package/types/raintonic-formaui-components-button-group.d.ts

@@ -0,0 +1,61 @@
+import * as i0 from '@angular/core';
+import { AfterContentInit } from '@angular/core';
+
+/**
+ * # Button Group Component
+ *
+ * A container component that groups multiple buttons together, creating a unified
+ * visual element with connected borders. Follows Carbon Design System patterns.
+ *
+ * ## Features
+ * - Groups multiple buttons into a single visual unit
+ * - Removes internal border-radius, keeping only the extremities rounded
+ * - Surface-02 background with small padding
+ * - Automatically handles button border-radius for first and last buttons
+ *
+ * ## Usage
+ *
+ * ### Basic Button Group
+ * ```html
+ * <fui-button-group>
+ *   <button fuiButton variant="outline">Left</button>
+ *   <button fuiButton variant="outline">Center</button>
+ *   <button fuiButton variant="outline">Right</button>
+ * </fui-button-group>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiButtonGroupComponent } from '@raintonic/formaui/components/button-group';
+ * import { FuiButtonDirective } from '@raintonic/formaui/components/button';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiButtonGroupComponent, FuiButtonDirective],
+ *   template: `
+ *     <fui-button-group>
+ *       <button fuiButton variant="outline">Option 1</button>
+ *       <button fuiButton variant="outline">Option 2</button>
+ *       <button fuiButton variant="outline">Option 3</button>
+ *     </fui-button-group>
+ *   `
+ * })
+ * export class MyComponent {}
+ * ```
+ */
+declare class FuiButtonGroupComponent implements AfterContentInit {
+    /**
+     * Accessible label for the button group
+     */
+    readonly ariaLabel: i0.InputSignal<string | undefined>;
+    private readonly _elementRef;
+    private readonly _renderer;
+    constructor();
+    ngAfterContentInit(): void;
+    private _updateButtonStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiButtonGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiButtonGroupComponent, "fui-button-group", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { FuiButtonGroupComponent };
+//# sourceMappingURL=raintonic-formaui-components-button-group.d.ts.map

package/types/raintonic-formaui-components-button-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-button-group.d.ts","sources":["../../../lib/components/button-group/button-group.component.ts"],"mappings":";;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;AACH,cAaa,uBAAwB,YAAW,gBAAgB;AAC9D;;AAEG;wBACeA,EAAA,CAAA,WAAA;AAElB;AACA;;AASA;AAIA;yCApBW,uBAAuB;2CAAvB,uBAAuB;AA2CnC;;;;","names":["_angular_core"]}

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

@@ -0,0 +1,116 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, Signal } from '@angular/core';
+
+/**
+ * Available button variants following Carbon Design System patterns
+ */
+type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'outline' | 'danger' | 'link' | 'icon';
+/**
+ * Available button sizes
+ */
+type ButtonSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+declare const FUI_BUTTON_VARIANTS: readonly ["primary", "secondary", "ghost", "outline", "danger", "link", "icon"];
+declare const FUI_BUTTON_SIZES: readonly ["sm", "md", "lg", "xl", "2xl"];
+type ButtonType = 'button' | 'submit' | 'reset';
+/**
+ * # Button Directive
+ *
+ * A versatile button directive that can be applied to both `<button>` and `<a>` elements.
+ * Follows Carbon Design System patterns with full accessibility support.
+ *
+ * ## Features
+ * - Multiple variants: primary, secondary,ghost, outline, danger, link
+ * - Six sizes: sm, md, lg, xl, 2xl, field
+ * - Full accessibility support (ARIA attributes, keyboard navigation)
+ * - Loading and disabled states
+ * - Icon support with proper spacing
+ * - Full-width option
+ * - Works with both button and anchor elements
+ *
+ *
+ * ### Link Button
+ * ```html
+ * <a fuiButton href="/dashboard" variant="ghost">Go to Dashboard</a>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiButtonDirective } from '@raintonic/formaui/components/button';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiButtonDirective],
+ *   template: `
+ *     <button fuiButton variant="primary" (click)="save()">
+ *       Save Changes
+ *     </button>
+ *   `
+ * })
+ * export class MyComponent {
+ *   save() {
+ *     // Handle save action
+ *   }
+ * }
+ * ```
+ */
+declare class FuiButtonDirective implements AfterViewInit {
+    /**
+     * Button variant that determines the color scheme
+     * @default 'primary'
+     */
+    readonly variant: _angular_core.InputSignalWithTransform<ButtonVariant, string>;
+    /**
+     * Button size
+     * @default 'md'
+     */
+    readonly size: _angular_core.InputSignalWithTransform<ButtonSize, string>;
+    /**
+     * Whether the button is disabled
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the button should take full width of its container
+     * @default false
+     */
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the button is in loading state
+     * @default false
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the button contains only an icon (for proper padding)
+     * @default false
+     */
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Accessible label for icon-only buttons.
+     * Required when `iconOnly` is true so screen readers can announce the button's purpose.
+     */
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    /**
+     * Button type for native button elements
+     * @default 'button'
+     */
+    readonly type: _angular_core.InputSignal<ButtonType>;
+    readonly computedClasses: Signal<string>;
+    private readonly _elementRef;
+    private readonly _renderer;
+    get isButton(): boolean;
+    get isAnchor(): boolean;
+    constructor();
+    ngAfterViewInit(): void;
+    onClick(event: Event): void;
+    onKeydown(event: Event): void;
+    onKeyup(event: Event): void;
+    private _addLoadingSpinner;
+    private _removeLoadingSpinner;
+    private _syncAnchorHrefDisabledState;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FuiButtonDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FuiButtonDirective, "button[fuiButton], a[fuiButton]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { FUI_BUTTON_SIZES, FUI_BUTTON_VARIANTS, FuiButtonDirective };
+export type { ButtonSize, ButtonType, ButtonVariant };
+//# sourceMappingURL=raintonic-formaui-components-button.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-button.d.ts","sources":["../../../lib/components/button/button.directive.ts"],"mappings":";;;AAcA;;AAEG;KACS,aAAa;AAEzB;;AAEG;AACG,KAAM,UAAU;AAEtB,cAAa,mBAAmB;AAChC,cAAa,gBAAgB;AAEvB,KAAM,UAAU;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCG;AACH,cAmBa,kBAAmB,YAAW,aAAa;AACtD;;;AAGG;sBACa,aAAA,CAAA,wBAAA,CAAA,aAAA;AAIhB;;;AAGG;mBACU,aAAA,CAAA,wBAAA,CAAA,UAAA;AAIb;;;AAGG;uBACc,aAAA,CAAA,wBAAA;AAEjB;;;AAGG;wBACe,aAAA,CAAA,wBAAA;AAElB;;;AAGG;sBACa,aAAA,CAAA,wBAAA;AAEhB;;;AAGG;uBACc,aAAA,CAAA,wBAAA;AAEjB;;;AAGG;wBACe,aAAA,CAAA,WAAA;AAElB;;;AAGG;mBACU,aAAA,CAAA,WAAA,CAAA,UAAA;AAGb,8BAA0B,MAAM;AAsBhC;AACA;;;;AAsBA;AASA,mBAAe,KAAK;AASpB,qBAAiB,KAAK;AAoBtB,mBAAe,KAAK;AASpB;AAgBA;AAOA;oDAzKW,kBAAkB;sDAAlB,kBAAkB;AAwL9B;;;;","names":[]}

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

@@ -0,0 +1,191 @@
+import * as i0 from '@angular/core';
+import { InputSignal, AfterContentInit, WritableSignal, Signal } from '@angular/core';
+
+/**
+ * # FuiCardHeader Component
+ *
+ * Header section for cards with optional title, subtitle, and additional content.
+ *
+ * ## Usage
+ * ```html
+ * <fui-card-header title="Card Title" subtitle="Optional subtitle">
+ *   <button fuiButton variant="ghost">
+ *     <fui-icon name="dots-three"></fui-icon>
+ *   </button>
+ * </fui-card-header>
+ * ```
+ */
+declare class FuiCardHeaderComponent {
+    /**
+     * Unique id for linking with aria-labelledby from the card
+     */
+    readonly hostId: string;
+    /**
+     * Main title text for the card header
+     */
+    readonly title: InputSignal<string | undefined>;
+    /**
+     * Optional subtitle text for the card header
+     */
+    readonly subtitle: InputSignal<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiCardHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiCardHeaderComponent, "fui-card-header", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * # FuiCardActions Component
+ *
+ * Actions section for cards, typically containing buttons or other interactive elements.
+ *
+ * ## Usage
+ * ```html
+ * <fui-card-actions align="end">
+ *   <button fuiButton variant="tertiary">Cancel</button>
+ *   <button fuiButton variant="primary" color="primary">Save</button>
+ * </fui-card-actions>
+ * ```
+ *
+ * ### Paddingless Actions
+ * ```html
+ * <fui-card-actions align="start" paddingless="true">
+ *   <button fuiButton variant="ghost">
+ *     <fui-icon name="heart"></fui-icon>
+ *   </button>
+ * </fui-card-actions>
+ * ```
+ */
+declare class FuiCardActionsComponent {
+    /**
+     * Alignment of actions within the container
+     * @default 'end'
+     */
+    readonly align: InputSignal<'start' | 'center' | 'end'>;
+    /**
+     * Whether to remove padding from the actions container
+     * @default false
+     */
+    readonly paddingless: InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiCardActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiCardActionsComponent, "fui-card-actions", never, { "align": { "alias": "align"; "required": false; "isSignal": true; }; "paddingless": { "alias": "paddingless"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Available card variants following Carbon Design System patterns
+ */
+type FuiCardVariant = 'elevated' | 'outlined' | 'flat';
+/**
+ * Available padding options for card content
+ */
+type FuiCardPadding = 'none' | 'sm' | 'md' | 'lg' | 'xl';
+/**
+ * # FuiCard Component
+ *
+ * A flexible container component following Carbon Design System patterns.
+ * Provides a structured layout with optional header, content, and actions sections.
+ *
+ * ## Features
+ * - Multiple variants: elevated, outlined, flat
+ * - Configurable padding: none, sm, md, lg, xl
+ * - Structured content areas: header, content, actions
+ * - Clickable state support with hover animations
+ * - Disabled state support
+ * - Full accessibility support
+ * - Smooth motion transitions
+ *
+ * ## Usage
+ *
+ * ### Basic Card
+ * ```html
+ * <fui-card>
+ *   <p>Card content goes here</p>
+ * </fui-card>
+ * ```
+ *
+ * ### Card with Header and Actions
+ * ```html
+ * <fui-card variant="outlined">
+ *   <fui-card-header title="Card Title" subtitle="Optional subtitle">
+ *     <button fuiButton variant="ghost" size="sm" [iconOnly]="true">
+ *       <fui-icon name="overflow-menu-vertical"></fui-icon>
+ *     </button>
+ *   </fui-card-header>
+ *
+ *   <p>Main card content</p>
+ *
+ *   <fui-card-actions align="end">
+ *     <button fuiButton variant="secondary" kind="ghost">Cancel</button>
+ *     <button fuiButton variant="primary">Save</button>
+ *   </fui-card-actions>
+ * </fui-card>
+ * ```
+ *
+ * ### Clickable Card
+ * ```html
+ * <fui-card [clickable]="true" (click)="handleCardClick()">
+ *   <p>This entire card is clickable</p>
+ * </fui-card>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { FuiCardComponent, FuiCardHeaderComponent, FuiCardActionsComponent } from '@raintonic/formaui/components/card';
+ *
+ * @Component({
+ *   standalone: true,
+ *   imports: [FuiCardComponent, FuiCardHeaderComponent, FuiCardActionsComponent],
+ *   template: `
+ *     <fui-card variant="elevated" padding="lg">
+ *       <fui-card-header title="User Profile"></fui-card-header>
+ *       <div class="user-info">
+ *         <p>User details here...</p>
+ *       </div>
+ *       <fui-card-actions>
+ *         <button fuiButton>Edit</button>
+ *       </fui-card-actions>
+ *     </fui-card>
+ *   `
+ * })
+ * export class UserCardComponent {}
+ * ```
+ */
+declare class FuiCardComponent implements AfterContentInit {
+    /**
+     * Card variant that determines the visual style
+     * @default 'outlined'
+     */
+    readonly variant: InputSignal<FuiCardVariant>;
+    /**
+     * Padding applied to card content
+     * @default 'lg'
+     */
+    readonly padding: InputSignal<FuiCardPadding>;
+    /**
+     * Whether the card is clickable (adds hover effects and cursor pointer)
+     * @default false
+     */
+    readonly clickable: InputSignal<boolean>;
+    /**
+     * Whether the card is disabled
+     * @default false
+     */
+    readonly disabled: InputSignal<boolean>;
+    readonly hovered: WritableSignal<boolean>;
+    readonly liftState: Signal<'idle' | 'lifted'>;
+    headerCmp?: FuiCardHeaderComponent;
+    actionsCmp?: FuiCardActionsComponent;
+    headerId: string;
+    readonly computedClasses: Signal<string>;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onClick(event: MouseEvent): void;
+    ngAfterContentInit(): void;
+    get hasHeader(): boolean;
+    get hasActions(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuiCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FuiCardComponent, "fui-card", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["headerCmp", "actionsCmp"], ["fui-card-header, [rtCardHeader]", "*", "fui-card-actions, [rtCardActions]"], true, never>;
+}
+
+export { FuiCardActionsComponent, FuiCardComponent, FuiCardHeaderComponent };
+export type { FuiCardPadding, FuiCardVariant };
+//# sourceMappingURL=raintonic-formaui-components-card.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"raintonic-formaui-components-card.d.ts","sources":["../../../lib/components/card/card-header.component.ts","../../../lib/components/card/card-actions.component.ts","../../../lib/components/card/card.component.ts"],"mappings":";;;AAEA;;;;;;;;;;;;;AAaG;AACH,cASa,sBAAsB;AACjC;;AAEG;;AAGH;;AAEG;oBACa,WAAW;AAE3B;;AAEG;uBACgB,WAAW;yCAdnB,sBAAsB;2CAAtB,sBAAsB;AAelC;;ACtCD;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH,cAYa,uBAAuB;AAClC;;;AAGG;oBACa,WAAW;AAE3B;;;AAGG;AACH,0BAAsB,WAAW;yCAXtB,uBAAuB;2CAAvB,uBAAuB;AAYnC;;AC9BD;;AAEG;AACG,KAAM,cAAc;AAE1B;;AAEG;AACG,KAAM,cAAc;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEG;AACH,cAiBa,gBAAiB,YAAW,gBAAgB;AACvD;;;AAGG;AACH,sBAAkB,WAAW,CAAC,cAAc;AAE5C;;;AAGG;AACH,sBAAkB,WAAW,CAAC,cAAc;AAE5C;;;AAGG;AACH,wBAAoB,WAAW;AAE/B;;;AAGG;AACH,uBAAmB,WAAW;AAG9B,sBAAkB,cAAc;wBACZ,MAAM;gBAKwB,sBAAsB;iBACpB,uBAAuB;AAE3E;AAGA,8BAA0B,MAAM;AAmBhC;AAOA;AAKA,qBAAiB,aAAa;AAQ9B,mBAAe,UAAU;AAOzB;;;yCApFW,gBAAgB;2CAAhB,gBAAgB;AAiG5B;;;;","names":[]}