gravitas-ui 0.1.0

package/types/gravitas-ui.d.ts

@@ -0,0 +1,877 @@
+import * as i0 from '@angular/core';
+import { ElementRef, EventEmitter, OnChanges, SimpleChanges, ChangeDetectorRef, OnDestroy, AfterContentInit, QueryList, ApplicationRef, Renderer2, NgZone } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import * as rxjs from 'rxjs';
+
+type ButtonVariant = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'light' | 'dark' | 'link';
+type ButtonSize = 'sm' | 'md' | 'lg';
+type ButtonAppearance = 'solid' | 'soft' | 'outline' | 'ghost' | 'link';
+declare class Button {
+    buttonElement?: ElementRef<HTMLButtonElement>;
+    /** Native button type attribute. */
+    type: 'button' | 'submit' | 'reset';
+    /** Visual style variant. Maps to Bootstrap variants (btn-*) with Gravitas styling. */
+    variant: ButtonVariant;
+    /** Visual treatment independent from semantic variant. */
+    appearance: ButtonAppearance;
+    /** Size variant. Maps to Bootstrap size classes (btn-sm / btn-lg). */
+    size: ButtonSize;
+    /** Disables the button. */
+    disabled: boolean;
+    /** Shows a busy state (disables button + shows spinner). */
+    loading: boolean;
+    /** If true, makes the button full width. */
+    fullWidth: boolean;
+    /** Optional label shown while loading (ex: "Saving..."). If empty, shows normal content. */
+    loadingText: string;
+    /** Extra CSS classes applied to the button element (ex: "mt-3 px-4"). */
+    className: string;
+    get nativeButton(): HTMLButtonElement | null;
+    get isDisabled(): boolean;
+    get btnClass(): string;
+    get resolvedAppearance(): ButtonAppearance;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Button, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Button, "gv-button", never, { "type": { "alias": "type"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, {}, never, ["[gvIconLeft]", "*", "[gvIconRight]"], true, never>;
+}
+
+declare class Card {
+    title: string | null;
+    subtitle: string | null;
+    /** Force header on/off. null = auto (shows if title/subtitle/actions exist) */
+    showHeader: boolean | null;
+    /** Makes the card fill its container height */
+    fullHeight: boolean;
+    /** Enables hover/press styles + click behavior */
+    interactive: boolean;
+    /** Disables interactions (no hover, no click, no keyboard activation) */
+    disabled: boolean;
+    /** Extra classes (Bootstrap utilities etc.) */
+    className: string;
+    cardClick: EventEmitter<MouseEvent | KeyboardEvent>;
+    /** Accessibility: only focusable when interactive and not disabled */
+    get roleAttr(): "button" | null;
+    get tabIndexAttr(): 0 | null;
+    get ariaDisabled(): string | null;
+    get hasHeader(): boolean;
+    get cardClass(): string;
+    onHostClick(event: MouseEvent): void;
+    onHostKeydown(event: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Card, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Card, "gv-card", never, { "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "fullHeight": { "alias": "fullHeight"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "cardClick": "cardClick"; }, never, ["[gvCardActions]", "*", "[gvCardFooter]"], true, never>;
+}
+
+type InputSize = 'sm' | 'md' | 'lg';
+type InputType = 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search' | 'date' | 'datetime-local';
+declare class InputComponent implements ControlValueAccessor {
+    ngControl: NgControl;
+    private readonly generatedId;
+    id?: string;
+    label?: string;
+    placeholder: string;
+    hint?: string;
+    set helperText(value: string | undefined);
+    /** If set, overrides control-based validation UI */
+    error?: string;
+    type: InputType;
+    size: InputSize;
+    disabled: boolean;
+    readonly: boolean;
+    /** Bootstrap utilities */
+    className: string;
+    /** Show required asterisk (doesn't enforce validation) */
+    required: boolean;
+    /** Optional projected "prefix" / "suffix" areas */
+    hasPrefix: boolean;
+    hasSuffix: boolean;
+    value: string | number | null;
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    constructor(ngControl: NgControl);
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    private control;
+    readonly isInvalid: i0.Signal<boolean>;
+    get inputId(): string;
+    get describedBy(): string;
+    get fieldHelperText(): string | null;
+    get isDateLike(): boolean;
+    get inputClasses(): string;
+    get errorText(): string | null;
+    handleInput(value: string): void;
+    handleBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, [{ optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "gv-input", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "error": { "alias": "error"; "required": false; }; "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "className": { "alias": "className"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hasPrefix": { "alias": "hasPrefix"; "required": false; }; "hasSuffix": { "alias": "hasSuffix"; "required": false; }; }, {}, never, ["[gvPrefix]", "[gvSuffix]"], true, never>;
+}
+
+type GvSelectSize = 'sm' | 'md' | 'lg';
+type SelectValue<T> = T | T[] | null;
+interface GvSelectOption<T = any> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+declare class Select<T = any> implements ControlValueAccessor, OnChanges {
+    private host;
+    private readonly generatedId;
+    id?: string;
+    label: string;
+    helperText: string;
+    placeholder: string;
+    error: string | null;
+    required: boolean;
+    size: GvSelectSize;
+    fullWidth: boolean;
+    className: string;
+    multiple: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    noResultsText: string;
+    clearable: boolean;
+    compareWith?: (a: T, b: T) => boolean;
+    options: GvSelectOption<T>[];
+    loading: boolean;
+    loadingText: string;
+    value: SelectValue<T>;
+    disabled: boolean;
+    isOpen: boolean;
+    searchTerm: string;
+    private onChange;
+    private onTouched;
+    private valueMap;
+    constructor(host: ElementRef<HTMLElement>);
+    get hostFullWidth(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    writeValue(value: SelectValue<T>): void;
+    registerOnChange(fn: (value: SelectValue<T>) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private rebuildValueMap;
+    getOptionKey(index: number): string;
+    private normalizeValueForMode;
+    stringifyValue(v: T): string;
+    private sameValue;
+    isSelected(v: T): boolean;
+    isOptionDisabled(opt: GvSelectOption<T>): boolean;
+    get filteredOptions(): GvSelectOption<T>[];
+    get selectedOptions(): GvSelectOption<T>[];
+    get displayLabel(): string;
+    get useCustomDropdown(): boolean;
+    get controlId(): string;
+    get labelId(): string | null;
+    get helperTextId(): string | null;
+    get errorId(): string | null;
+    get describedBy(): string | null;
+    get selectClass(): string;
+    get triggerClass(): string;
+    handleNativeChange(event: Event): void;
+    toggleOpen(): void;
+    open(): void;
+    close(): void;
+    selectOption(opt: GvSelectOption<T>): void;
+    removeSelected(opt: GvSelectOption<T>, event?: MouseEvent): void;
+    clear(event?: MouseEvent): void;
+    trackByIndex(index: number): number;
+    trackByValue: (_: number, opt: GvSelectOption<T>) => string;
+    handleBlur(): void;
+    onDocumentClick(event: MouseEvent): void;
+    onEscape(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Select<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Select<any>, "gv-select", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "error": { "alias": "error"; "required": false; }; "required": { "alias": "required"; "required": false; }; "size": { "alias": "size"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "className": { "alias": "className"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "noResultsText": { "alias": "noResultsText"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "compareWith": { "alias": "compareWith"; "required": false; }; "options": { "alias": "options"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FormField {
+    /** Visible label above the control */
+    label: string | null;
+    /** Optional supporting description shown between label and control */
+    description: string | null;
+    /** Shows a red asterisk next to label */
+    required: boolean;
+    /** Helper text (only shows when there is no error) */
+    helperText: string | null;
+    /** Error message (shows under the control) */
+    error: string | null;
+    /** Makes the field take full width */
+    fullWidth: boolean;
+    /**
+     * Use this to connect label->control and error/helper -> aria-describedby.
+     * Example: controlId="email"
+     */
+    controlId: string;
+    /** Optional: set to false to hide the label visually (keeps layout consistent) */
+    showLabel: boolean;
+    get hostClass(): string;
+    get describedById(): string;
+    get labelId(): string;
+    get hasError(): boolean;
+    get hasHelper(): boolean;
+    get hasDescription(): boolean;
+    get describedByText(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormField, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormField, "gv-form-field", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "required": { "alias": "required"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "error": { "alias": "error"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "controlId": { "alias": "controlId"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; }, {}, never, ["[prefix]", "*", "[suffix]"], true, never>;
+}
+
+type GvCheckboxSize = 'sm' | 'md' | 'lg';
+declare class Checkbox implements ControlValueAccessor {
+    private readonly cdr;
+    private readonly generatedId;
+    label: string;
+    description: string;
+    helperText: string;
+    errorText: string;
+    set error(value: string | null | undefined);
+    size: GvCheckboxSize;
+    inputId: string;
+    set id(value: string | null | undefined);
+    name?: string;
+    disabled: boolean;
+    required: boolean;
+    private _indeterminate;
+    set indeterminate(value: boolean);
+    get indeterminate(): boolean;
+    checkedChange: EventEmitter<boolean>;
+    inputRef?: ElementRef<HTMLInputElement>;
+    checked: boolean;
+    focused: boolean;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef);
+    get hostClasses(): string;
+    writeValue(value: boolean | null): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInputChange(event: Event): void;
+    handleBlur(): void;
+    handleFocus(): void;
+    private syncIndeterminateState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Checkbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Checkbox, "gv-checkbox", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "error": { "alias": "error"; "required": false; }; "size": { "alias": "size"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_indeterminate: unknown;
+}
+
+type GvRadioSize = 'sm' | 'md' | 'lg';
+declare class Radio implements ControlValueAccessor {
+    private readonly cdr;
+    private readonly generatedId;
+    label: string;
+    description: string;
+    helperText: string;
+    errorText: string;
+    set error(value: string | null | undefined);
+    size: GvRadioSize;
+    inputId: string;
+    set id(value: string | null | undefined);
+    name?: string;
+    value: unknown;
+    disabled: boolean;
+    required: boolean;
+    valueChange: EventEmitter<unknown>;
+    inputRef?: ElementRef<HTMLInputElement>;
+    modelValue: unknown;
+    focused: boolean;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef);
+    get hostClasses(): string;
+    get checked(): boolean;
+    writeValue(value: unknown): void;
+    registerOnChange(fn: (value: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInputChange(event: Event): void;
+    handleBlur(): void;
+    handleFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Radio, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Radio, "gv-radio", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "error": { "alias": "error"; "required": false; }; "size": { "alias": "size"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+type GvSwitchSize = 'sm' | 'md' | 'lg';
+declare class Switch implements ControlValueAccessor {
+    private readonly cdr;
+    private readonly generatedId;
+    label: string;
+    description: string;
+    helperText: string;
+    errorText: string;
+    set error(value: string | null | undefined);
+    size: GvSwitchSize;
+    inputId: string;
+    set id(value: string | null | undefined);
+    name?: string;
+    disabled: boolean;
+    required: boolean;
+    checkedChange: EventEmitter<boolean>;
+    checked: boolean;
+    focused: boolean;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef);
+    get hostClasses(): string;
+    writeValue(value: boolean | null): void;
+    registerOnChange(fn: (value: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInputChange(event: Event): void;
+    handleBlur(): void;
+    handleFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Switch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Switch, "gv-switch", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "error": { "alias": "error"; "required": false; }; "size": { "alias": "size"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+}
+
+type GvTextareaSize = 'sm' | 'md' | 'lg';
+type GvTextareaResize = 'none' | 'vertical' | 'both';
+declare class Textarea implements ControlValueAccessor {
+    private readonly cdr;
+    private readonly generatedId;
+    label: string;
+    description: string;
+    helperText: string;
+    errorText: string;
+    set error(value: string | null | undefined);
+    placeholder: string;
+    inputId: string;
+    set id(value: string | null | undefined);
+    name?: string;
+    rows: number;
+    size: GvTextareaSize;
+    resize: GvTextareaResize;
+    maxLength?: number;
+    disabled: boolean;
+    required: boolean;
+    readonly: boolean;
+    valueChange: EventEmitter<string>;
+    value: string;
+    focused: boolean;
+    private onChange;
+    private onTouched;
+    constructor(cdr: ChangeDetectorRef);
+    get hostClasses(): string;
+    get characterCount(): number;
+    get describedBy(): string | null;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    handleInput(event: Event): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Textarea, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Textarea, "gv-textarea", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "helperText": { "alias": "helperText"; "required": false; }; "errorText": { "alias": "errorText"; "required": false; }; "error": { "alias": "error"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "size": { "alias": "size"; "required": false; }; "resize": { "alias": "resize"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_required: unknown;
+    static ngAcceptInputType_readonly: unknown;
+}
+
+type ModalSize = 'sm' | 'md' | 'lg' | 'xl';
+type CloseReason = 'backdrop' | 'esc' | 'button';
+declare class Modal implements OnChanges, OnDestroy {
+    open: boolean;
+    title?: string;
+    subtitle?: string;
+    size: ModalSize;
+    /** UX controls */
+    closeOnBackdrop: boolean;
+    closeOnEsc: boolean;
+    /** When true, disables closing + shows overlayed spinner area (optional UI in CSS) */
+    loading: boolean;
+    /** Allows extra utility classes on the panel (ex: "border-0") */
+    panelClass: string;
+    openChange: EventEmitter<boolean>;
+    closed: EventEmitter<CloseReason>;
+    panelRef?: ElementRef<HTMLElement>;
+    readonly titleId: string;
+    private prevBodyOverflow;
+    private prevFocused;
+    get sizeClass(): string;
+    get panelClasses(): string;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Close triggers */
+    onBackdropMouseDown(): void;
+    onCloseButton(): void;
+    onDocKeydown(e: KeyboardEvent): void;
+    private requestClose;
+    private onOpen;
+    private onCloseCleanup;
+    private lockBodyScroll;
+    private unlockBodyScroll;
+    private trapFocus;
+    private getFocusable;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Modal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Modal, "gv-modal", never, { "open": { "alias": "open"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "size": { "alias": "size"; "required": false; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; }; "closeOnEsc": { "alias": "closeOnEsc"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; }, { "openChange": "openChange"; "closed": "closed"; }, never, ["*", "[gvFooter]"], true, never>;
+}
+
+type ToastVariant = 'primary' | 'success' | 'warning' | 'danger' | 'info' | 'dark';
+type ToastPosition = 'top-end' | 'top-start' | 'top-center' | 'bottom-end' | 'bottom-start' | 'bottom-center';
+interface ToastOptions {
+    id?: string;
+    title?: string;
+    message: string;
+    variant?: ToastVariant;
+    durationMs?: number;
+    dismissible?: boolean;
+    position?: ToastPosition;
+    ariaLive?: 'polite' | 'assertive';
+}
+interface ToastItem extends Required<Omit<ToastOptions, 'id'>> {
+    id: string;
+    createdAt: number;
+}
+
+declare class ToastService {
+    private readonly _toasts$;
+    readonly toasts$: rxjs.Observable<ToastItem[]>;
+    show(opts: ToastOptions): string;
+    dismiss(id: string): void;
+    clear(): void;
+    success(message: string, title?: string): string;
+    error(message: string, title?: string): string;
+    warning(message: string, title?: string): string;
+    info(message: string, title?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}
+
+declare class Toasts {
+    private readonly toastSvc;
+    readonly toasts$: rxjs.Observable<ToastItem[]>;
+    dismiss(id: string): void;
+    trackById(_: number, t: ToastItem): string;
+    positionClass(pos: ToastPosition): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Toasts, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Toasts, "gv-toasts", never, {}, {}, never, never, true, never>;
+}
+
+declare class Tab {
+    private tabs;
+    private cdr;
+    value: string;
+    disabled: boolean;
+    private _active;
+    private _btn;
+    get active(): boolean;
+    set active(next: boolean);
+    get buttonEl(): HTMLButtonElement | null;
+    constructor(tabs: Tabs | null, cdr: ChangeDetectorRef);
+    get tabIndex(): 0 | -1;
+    onClick(): void;
+    onKeydown(e: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Tab, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Tab, "gv-tab", never, { "value": { "alias": "value"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanel {
+    private cdr;
+    value: string;
+    private _active;
+    host: boolean;
+    get active(): boolean;
+    set active(next: boolean);
+    constructor(cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanel, "gv-tab-panel", never, { "value": { "alias": "value"; "required": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type TabsVariant = 'underline' | 'pill';
+declare class Tabs implements AfterContentInit {
+    private hostEl;
+    value: string | null;
+    valueChange: EventEmitter<string>;
+    variant: TabsVariant;
+    get dataVariant(): TabsVariant;
+    tabs: QueryList<Tab>;
+    panels: QueryList<TabPanel>;
+    private zone;
+    private destroyRef;
+    constructor(hostEl: ElementRef<HTMLElement>);
+    ngAfterContentInit(): void;
+    setValue(next: string, emit?: boolean): void;
+    private syncChildren;
+    /** Wait until Angular finishes applying DOM updates, then measure */
+    private updateIndicatorAfterRender;
+    /** Measure active tab button + write CSS vars on the list */
+    private updateIndicatorNow;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Tabs, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Tabs, "gv-tabs", never, { "value": { "alias": "value"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, { "valueChange": "valueChange"; }, ["tabs", "panels"], ["gv-tab-list", "gv-tab-panels"], true, never>;
+}
+
+declare class TabList {
+    hostClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabList, "gv-tab-list", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class TabPanels {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabPanels, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabPanels, "gv-tab-panels", never, {}, {}, never, ["*"], true, never>;
+}
+
+type GvLoaderVariant = 'spinner' | 'dots';
+type GvLoaderSize = 'sm' | 'md' | 'lg';
+declare class Loader {
+    variant: GvLoaderVariant;
+    size: GvLoaderSize;
+    label?: string;
+    inline: boolean;
+    overlay: boolean;
+    centered: boolean;
+    protected readonly baseClass = true;
+    get inlineClass(): boolean;
+    get overlayClass(): boolean;
+    get centeredClass(): boolean;
+    get spinnerClass(): boolean;
+    get dotsClass(): boolean;
+    get smClass(): boolean;
+    get mdClass(): boolean;
+    get lgClass(): boolean;
+    get ariaLabel(): string;
+    get showVisibleLabel(): boolean;
+    get dots(): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<Loader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Loader, "gv-loader", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "label": { "alias": "label"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "overlay": { "alias": "overlay"; "required": false; }; "centered": { "alias": "centered"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type GvTableSortDirection = 'asc' | 'desc' | null;
+type GvTableFilterType = 'text' | 'select' | 'number-range' | 'date-range';
+interface GvTableFilterOption {
+    label: string;
+    value: any;
+}
+interface GvTableColumnFilter {
+    type: GvTableFilterType;
+    options?: GvTableFilterOption[];
+}
+interface GvTableColumn<T = any> {
+    key: keyof T | string;
+    label: string;
+    sortable?: boolean;
+    searchable?: boolean;
+    width?: string;
+    align?: 'start' | 'center' | 'end';
+    filter?: GvTableColumnFilter;
+}
+interface GvTablePageSizeOption {
+    label: string;
+    value: number;
+}
+type GvNumberRangeFilterValue = {
+    min?: number | null;
+    max?: number | null;
+};
+type GvDateRangeFilterValue = {
+    from?: string | null;
+    to?: string | null;
+};
+type GvActiveFilterChip<T> = {
+    key: string;
+    label: string;
+    valueLabel: string;
+    column?: GvTableColumn<T>;
+    kind: 'global' | 'column';
+};
+declare class Table<T extends Record<string, any>> implements OnChanges {
+    columns: GvTableColumn<T>[];
+    rows: T[];
+    filterable: boolean;
+    showColumnFilters: boolean;
+    collapsibleFilters: boolean;
+    filtersExpanded: boolean;
+    filterPlaceholder: string;
+    pagination: boolean;
+    pageSize: number;
+    pageSizeOptions: GvTablePageSizeOption[];
+    rowLimit: number | null;
+    minBodyHeight: number;
+    loading: boolean;
+    emptyText: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    loadingTitle: string;
+    loadingDescription: string;
+    className: string;
+    striped: boolean;
+    hover: boolean;
+    compact: boolean;
+    filterTerm: string;
+    currentPage: number;
+    sortKey: string | null;
+    sortDirection: GvTableSortDirection;
+    columnFilters: Record<string, any>;
+    areFiltersOpen: boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    get processedRows(): T[];
+    get pagedRows(): T[];
+    get totalRows(): number;
+    get totalPages(): number;
+    get startRow(): number;
+    get endRow(): number;
+    get tableClass(): string;
+    get filterColumns(): GvTableColumn<T>[];
+    get hasColumnFilters(): boolean;
+    get searchableColumns(): GvTableColumn<T>[];
+    get shouldShowFiltersPanel(): boolean;
+    get activeFilterCount(): number;
+    get activeFilterChips(): GvActiveFilterChip<T>[];
+    get resolvedEmptyDescription(): string;
+    onFilterChange(): void;
+    onColumnFilterChange(): void;
+    onPageSizeChange(value: string | number): void;
+    toggleFilters(): void;
+    clearFilterChip(chip: GvActiveFilterChip<T>): void;
+    toggleSort(column: GvTableColumn<T>): void;
+    getSortDirection(column: GvTableColumn<T>): GvTableSortDirection;
+    goToPage(page: number): void;
+    previousPage(): void;
+    nextPage(): void;
+    clearAllFilters(): void;
+    trackByIndex(index: number): number;
+    trackByColumn: (_: number, column: GvTableColumn<T>) => string;
+    trackByChip: (_: number, chip: GvActiveFilterChip<T>) => string;
+    getCellValue(row: T, key: keyof T | string): any;
+    getAlignClass(column: GvTableColumn<T>): string;
+    getFilterKey(column: GvTableColumn<T>): string;
+    getFilterType(column: GvTableColumn<T>): GvTableFilterType | null;
+    getTextFilterValue(column: GvTableColumn<T>): string;
+    setTextFilterValue(column: GvTableColumn<T>, value: string): void;
+    getSelectFilterValue(column: GvTableColumn<T>): any;
+    setSelectFilterValue(column: GvTableColumn<T>, value: any): void;
+    getNumberRangeFilterValue(column: GvTableColumn<T>): GvNumberRangeFilterValue;
+    setNumberRangeFilterMin(column: GvTableColumn<T>, value: string | number | null): void;
+    setNumberRangeFilterMax(column: GvTableColumn<T>, value: string | number | null): void;
+    getDateRangeFilterValue(column: GvTableColumn<T>): GvDateRangeFilterValue;
+    setDateRangeFilterFrom(column: GvTableColumn<T>, value: string | null): void;
+    setDateRangeFilterTo(column: GvTableColumn<T>, value: string | null): void;
+    private initializeColumnFilters;
+    private applyGlobalSearch;
+    private applyColumnFilters;
+    private compareValues;
+    private ensureValidPage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Table<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Table<any>, "gv-table", never, { "columns": { "alias": "columns"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "showColumnFilters": { "alias": "showColumnFilters"; "required": false; }; "collapsibleFilters": { "alias": "collapsibleFilters"; "required": false; }; "filtersExpanded": { "alias": "filtersExpanded"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; "pagination": { "alias": "pagination"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "rowLimit": { "alias": "rowLimit"; "required": false; }; "minBodyHeight": { "alias": "minBodyHeight"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "emptyTitle": { "alias": "emptyTitle"; "required": false; }; "emptyDescription": { "alias": "emptyDescription"; "required": false; }; "loadingTitle": { "alias": "loadingTitle"; "required": false; }; "loadingDescription": { "alias": "loadingDescription"; "required": false; }; "className": { "alias": "className"; "required": false; }; "striped": { "alias": "striped"; "required": false; }; "hover": { "alias": "hover"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type GvSkeletonVariant = 'text' | 'rect' | 'circle';
+declare class Skeleton {
+    variant: GvSkeletonVariant;
+    width?: string;
+    height?: string;
+    lines: number;
+    animated: boolean;
+    protected readonly baseClass = true;
+    get animatedClass(): boolean;
+    get textClass(): boolean;
+    get rectClass(): boolean;
+    get circleClass(): boolean;
+    get skeletonWidth(): string | null;
+    get skeletonHeight(): string | null;
+    get resolvedLines(): number[];
+    get hostWidth(): string | null;
+    get hostHeight(): string | null;
+    lineWidth(index: number): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Skeleton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Skeleton, "gv-skeleton", never, { "variant": { "alias": "variant"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "animated": { "alias": "animated"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type GvDropdownAlign = 'start' | 'end';
+declare class DropdownTriggerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownTriggerDirective, "[gvDropdownTrigger]", never, {}, {}, never, never, true, never>;
+}
+declare class DropdownMenuDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMenuDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownMenuDirective, "[gvDropdownMenu]", never, {}, {}, never, never, true, never>;
+}
+declare class Dropdown {
+    private readonly hostRef;
+    private readonly cdr;
+    align: GvDropdownAlign;
+    disabled: boolean;
+    closeOnItemClick: boolean;
+    protected readonly baseClass = true;
+    get openClass(): boolean;
+    get disabledClass(): boolean;
+    get alignEndClass(): boolean;
+    open: boolean;
+    constructor(hostRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
+    toggle(event?: Event): void;
+    closeMenu(): void;
+    onTriggerKeydown(event: KeyboardEvent): void;
+    onMenuClick(event: MouseEvent): void;
+    onMenuKeydown(event: KeyboardEvent): void;
+    onDocumentClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Dropdown, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Dropdown, "gv-dropdown", never, { "align": { "alias": "align"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "closeOnItemClick": { "alias": "closeOnItemClick"; "required": false; }; }, {}, never, ["[gvDropdownTrigger]", "[gvDropdownMenu]"], true, never>;
+}
+
+type GvAvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type GvAvatarShape = 'circle' | 'rounded' | 'square';
+type GvAvatarBackground = 'subtle' | 'primary' | 'neutral';
+declare class Avatar {
+    src?: string;
+    alt?: string;
+    name?: string;
+    initials?: string;
+    size: GvAvatarSize;
+    shape: GvAvatarShape;
+    background: GvAvatarBackground;
+    imageFailed: boolean;
+    get hostClasses(): string;
+    get hasImage(): boolean;
+    get computedAlt(): string;
+    get displayInitials(): string;
+    get shouldShowInitials(): boolean;
+    get shouldShowProjectedContent(): boolean;
+    onImageError(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Avatar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Avatar, "gv-avatar", never, { "src": { "alias": "src"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "name": { "alias": "name"; "required": false; }; "initials": { "alias": "initials"; "required": false; }; "size": { "alias": "size"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "background": { "alias": "background"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+type GvBadgeVariant = 'neutral' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+type GvBadgeSize = 'sm' | 'md';
+declare class Badge {
+    variant: GvBadgeVariant;
+    size: GvBadgeSize;
+    pill: boolean;
+    dot: boolean;
+    protected readonly baseClass = true;
+    get neutralClass(): boolean;
+    get primaryClass(): boolean;
+    get successClass(): boolean;
+    get warningClass(): boolean;
+    get dangerClass(): boolean;
+    get infoClass(): boolean;
+    get smClass(): boolean;
+    get mdClass(): boolean;
+    get pillClass(): boolean;
+    get dotClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Badge, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Badge, "gv-badge", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "pill": { "alias": "pill"; "required": false; }; "dot": { "alias": "dot"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_pill: unknown;
+    static ngAcceptInputType_dot: unknown;
+}
+
+type GvAlertVariant = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+declare class Alert {
+    variant: GvAlertVariant;
+    title?: string;
+    dismissible: boolean;
+    dismissed: EventEmitter<void>;
+    protected visible: boolean;
+    protected readonly baseClass = true;
+    get neutralClass(): boolean;
+    get infoClass(): boolean;
+    get successClass(): boolean;
+    get warningClass(): boolean;
+    get dangerClass(): boolean;
+    get role(): string;
+    onDismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Alert, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Alert, "gv-alert", never, { "variant": { "alias": "variant"; "required": false; }; "title": { "alias": "title"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; }, { "dismissed": "dismissed"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_dismissible: unknown;
+}
+
+declare class Empty {
+    title: string;
+    description: string;
+    compact: boolean;
+    protected readonly baseClass = true;
+    get compactClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Empty, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Empty, "gv-empty", never, { "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, ["[gvEmptyActions]"], true, never>;
+    static ngAcceptInputType_compact: unknown;
+}
+
+type GvTooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+declare class GvTooltipPanelComponent {
+    text: string;
+    placement: GvTooltipPlacement;
+    maxWidth: number;
+    get hostClasses(): string;
+    get hostMaxWidth(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GvTooltipPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GvTooltipPanelComponent, "gv-tooltip-panel", never, { "text": { "alias": "text"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type GvTooltipTrigger = 'hover' | 'focus' | 'click' | 'manual';
+declare class GvTooltipDirective implements OnDestroy {
+    private readonly elementRef;
+    private readonly appRef;
+    private readonly renderer;
+    private readonly ngZone;
+    private readonly document;
+    text: string;
+    gvTooltipPlacement: GvTooltipPlacement;
+    gvTooltipTrigger: GvTooltipTrigger;
+    gvTooltipDisabled: boolean;
+    gvTooltipOffset: number;
+    gvTooltipMaxWidth: number;
+    private tooltipRef;
+    private removeScrollListener;
+    private removeResizeListener;
+    private removeDocumentClickListener;
+    private readonly isOpen;
+    private readonly tooltipId;
+    constructor(elementRef: ElementRef<HTMLElement>, appRef: ApplicationRef, renderer: Renderer2, ngZone: NgZone, document: Document);
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    onHostClick(event: MouseEvent): void;
+    onEscape(): void;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    ngOnDestroy(): void;
+    private bindGlobalListeners;
+    private unbindGlobalListeners;
+    private positionTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GvTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GvTooltipDirective, "[gvTooltip]", ["gvTooltip"], { "text": { "alias": "gvTooltip"; "required": false; }; "gvTooltipPlacement": { "alias": "gvTooltipPlacement"; "required": false; }; "gvTooltipTrigger": { "alias": "gvTooltipTrigger"; "required": false; }; "gvTooltipDisabled": { "alias": "gvTooltipDisabled"; "required": false; }; "gvTooltipOffset": { "alias": "gvTooltipOffset"; "required": false; }; "gvTooltipMaxWidth": { "alias": "gvTooltipMaxWidth"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_gvTooltipDisabled: unknown;
+}
+
+type GvIconButtonVariant = 'default' | 'ghost' | 'primary' | 'danger';
+type GvIconButtonSize = 'sm' | 'md' | 'lg';
+type GvIconButtonShape = 'rounded' | 'circle' | 'square';
+type GvIconButtonType = 'button' | 'submit' | 'reset';
+type GvIconButtonAppearance = 'solid' | 'soft' | 'outline' | 'ghost';
+declare class IconButton {
+    ariaLabel: string;
+    variant: GvIconButtonVariant;
+    appearance: GvIconButtonAppearance;
+    size: GvIconButtonSize;
+    shape: GvIconButtonShape;
+    type: GvIconButtonType;
+    disabled: boolean;
+    active: boolean;
+    buttonClick: EventEmitter<MouseEvent>;
+    get hostClasses(): string;
+    onClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconButton, "gv-icon-button", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "size": { "alias": "size"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_active: unknown;
+}
+
+type GvDividerOrientation = 'horizontal' | 'vertical';
+declare class Divider {
+    orientation: GvDividerOrientation;
+    label?: string;
+    inset: boolean;
+    get hostClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Divider, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Divider, "gv-divider", never, { "orientation": { "alias": "orientation"; "required": false; }; "label": { "alias": "label"; "required": false; }; "inset": { "alias": "inset"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_inset: unknown;
+}
+
+export { Alert, Avatar, Badge, Button, Card, Checkbox, Divider, Dropdown, DropdownMenuDirective, DropdownTriggerDirective, Empty, FormField, GvTooltipDirective, GvTooltipPanelComponent, IconButton, InputComponent, Loader, Modal, Radio, Select, Skeleton, Switch, Tab, TabList, TabPanel, TabPanels, Table, Tabs, Textarea, ToastService, Toasts };
+export type { GvAlertVariant, GvAvatarBackground, GvAvatarShape, GvAvatarSize, GvBadgeSize, GvBadgeVariant, GvCheckboxSize, GvDividerOrientation, GvDropdownAlign, GvIconButtonAppearance, GvIconButtonShape, GvIconButtonSize, GvIconButtonType, GvIconButtonVariant, GvLoaderSize, GvLoaderVariant, GvRadioSize, GvSelectOption, GvSelectSize, GvSkeletonVariant, GvSwitchSize, GvTableColumn, GvTableColumnFilter, GvTableFilterOption, GvTableFilterType, GvTablePageSizeOption, GvTableSortDirection, GvTextareaResize, GvTextareaSize, GvTooltipPlacement, GvTooltipTrigger, SelectValue, TabsVariant, ToastItem, ToastOptions, ToastPosition, ToastVariant };