primenglab 22.0.0-beta.1

package/types/primenglab-autofocus.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { BaseComponent } from 'primenglab/basecomponent';
+
+/**
+ * AutoFocus manages focus on focusable element on load.
+ * @group Components
+ */
+declare class AutoFocus extends BaseComponent {
+    /**
+     * When present, it specifies that the component should automatically get focus on load.
+     * @group Props
+     */
+    autofocus: i0.InputSignalWithTransform<boolean, unknown>;
+    focused: boolean;
+    host: ElementRef;
+    onAfterContentChecked(): void;
+    onAfterViewChecked(): void;
+    autoFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocus, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoFocus, "[pAutoFocus]", never, { "autofocus": { "alias": "pAutoFocus"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class AutoFocusModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFocusModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AutoFocusModule, never, [typeof AutoFocus], [typeof AutoFocus]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AutoFocusModule>;
+}
+
+export { AutoFocus, AutoFocusModule };

package/types/primenglab-avatar.d.ts

@@ -0,0 +1,133 @@
+import { AvatarPassThrough, AvatarSize, AvatarShape } from 'primenglab/types/avatar';
+export * from 'primenglab/types/avatar';
+import * as _angular_core from '@angular/core';
+import { BaseComponent } from 'primenglab/basecomponent';
+import * as i1 from 'primenglab/bind';
+import { Bind } from 'primenglab/bind';
+import * as _primeuix_styled from '@primeuix/styled';
+import { BaseStyle } from 'primenglab/base';
+import * as i2 from 'primenglab/api';
+
+/**
+ *
+ * Avatar represents people using icons, labels and images.
+ *
+ * - [Live Demo](https://primeng.org/avatar)
+ *
+ * @module avatarstyle
+ *
+ */
+declare enum AvatarClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-avatar",
+    /**
+     * Class name of the label element
+     */
+    label = "p-avatar-label",
+    /**
+     * Class name of the icon element
+     */
+    icon = "p-avatar-icon",
+    /**
+     * Container element in image mode
+     */
+    image = "p-avatar-image",
+    /**
+     * Container element with a circle shape
+     */
+    circle = "p-avatar-circle",
+    /**
+     *  Container element with a large size
+     */
+    large = "p-avatar-lg",
+    /**
+     *  Container element with an xlarge size
+     */
+    xlarge = "p-avatar-xl"
+}
+declare class AvatarStyle extends BaseStyle {
+    name: string;
+    style: _primeuix_styled.StyleType;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-avatar-image': boolean;
+            'p-avatar-circle': boolean;
+            'p-avatar-lg': boolean;
+            'p-avatar-xl': boolean;
+        })[];
+        label: string;
+        icon: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AvatarStyle>;
+}
+interface AvatarStyle extends BaseStyle {
+}
+
+/**
+ * Avatar represents people using icons, labels and images.
+ * @group Components
+ */
+declare class Avatar extends BaseComponent<AvatarPassThrough> {
+    componentName: string;
+    $pcAvatar: Avatar | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Defines the text to display.
+     * @group Props
+     */
+    label: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Defines the icon to display.
+     * @group Props
+     */
+    icon: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Defines the image to display.
+     * @group Props
+     */
+    image: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Size of the element.
+     * @group Props
+     */
+    size: _angular_core.InputSignal<AvatarSize>;
+    /**
+     * Shape of the element.
+     * @group Props
+     */
+    shape: _angular_core.InputSignal<AvatarShape>;
+    /**
+     * Establishes a string value that labels the component.
+     * @group Props
+     */
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Establishes relationships between the component and label(s) where its value should be one or more element IDs.
+     * @group Props
+     */
+    ariaLabelledBy: _angular_core.InputSignal<string | undefined>;
+    /**
+     * This event is triggered if an error occurs while loading an image file.
+     * @param {Event} event - Browser event.
+     * @group Emits
+     */
+    onImageError: _angular_core.OutputEmitterRef<Event>;
+    _componentStyle: AvatarStyle;
+    dataP: _angular_core.Signal<string | undefined>;
+    imageError(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Avatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Avatar, "p-avatar", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "image": { "alias": "image"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; }, { "onImageError": "onImageError"; }, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class AvatarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AvatarModule, never, [typeof Avatar, typeof i2.SharedModule], [typeof Avatar, typeof i2.SharedModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AvatarModule>;
+}
+
+export { Avatar, AvatarClasses, AvatarModule, AvatarStyle };

package/types/primenglab-avatargroup.d.ts

@@ -0,0 +1,58 @@
+import { BaseComponent } from 'primenglab/basecomponent';
+import * as i1 from 'primenglab/bind';
+import { Bind } from 'primenglab/bind';
+import { AvatarGroupPassThrough } from 'primenglab/types/avatargroup';
+import { BaseStyle } from 'primenglab/base';
+import * as i0 from '@angular/core';
+import { CSSProperties } from 'primenglab/types/shared';
+import * as i2 from 'primenglab/api';
+
+/**
+ *
+ * A set of Avatars can be displayed together using the AvatarGroup component.
+ *
+ * [Live Demo](https://www.primeng.org/avatar/)
+ *
+ * @module avatargroupstyle
+ *
+ */
+declare enum AvatarGroupClasses {
+    root = "p-avatar-group"
+}
+declare class AvatarGroupStyle extends BaseStyle {
+    name: string;
+    classes: {
+        root: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroupStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AvatarGroupStyle>;
+}
+interface AvatarGroupStyle extends BaseStyle {
+}
+
+/**
+ * AvatarGroup is a helper component for Avatar.
+ * @group Components
+ */
+declare class AvatarGroup extends BaseComponent<AvatarGroupPassThrough> {
+    componentName: string;
+    $pcAvatarGroup: AvatarGroup | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Inline style of the component.
+     * @group Props
+     */
+    style: CSSProperties;
+    get hostStyle(): CSSProperties;
+    _componentStyle: AvatarGroupStyle;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AvatarGroup, "p-avatar-group, p-avatargroup", never, { "style": { "alias": "style"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class AvatarGroupModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AvatarGroupModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AvatarGroupModule, never, [typeof AvatarGroup, typeof i2.SharedModule], [typeof AvatarGroup, typeof i2.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AvatarGroupModule>;
+}
+
+export { AvatarGroup, AvatarGroupClasses, AvatarGroupModule, AvatarGroupStyle };

package/types/primenglab-badge.d.ts

@@ -0,0 +1,96 @@
+import * as _angular_core from '@angular/core';
+import { BaseComponent } from 'primenglab/basecomponent';
+import * as i1 from 'primenglab/bind';
+import { Bind } from 'primenglab/bind';
+import { BadgePassThrough, BadgeSize, BadgeSeverity } from 'primenglab/types/badge';
+import { BaseStyle } from 'primenglab/base';
+import * as i2 from 'primenglab/api';
+
+/**
+ *
+ * Badge represents people using icons, labels and images.
+ *
+ * [Live Demo](https://www.primeng.org/badge)
+ *
+ * @module badgestyle
+ *
+ */
+declare enum BadgeClasses {
+    /**
+     * Class name of the root element
+     */
+    root = "p-badge"
+}
+declare class BadgeStyle extends BaseStyle {
+    name: string;
+    style: string;
+    classes: {
+        root: ({ instance }: {
+            instance: any;
+        }) => (string | {
+            'p-badge-circle': boolean;
+            'p-badge-dot': boolean;
+            'p-badge-sm': boolean;
+            'p-badge-lg': boolean;
+            'p-badge-xl': boolean;
+            'p-badge-info': boolean;
+            'p-badge-success': boolean;
+            'p-badge-warn': boolean;
+            'p-badge-danger': boolean;
+            'p-badge-secondary': boolean;
+            'p-badge-contrast': boolean;
+        })[];
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BadgeStyle>;
+}
+interface BadgeStyle extends BaseStyle {
+}
+
+/**
+ * Badge is a small status indicator for another element.
+ * @group Components
+ */
+declare class Badge extends BaseComponent<BadgePassThrough> {
+    componentName: string;
+    $pcBadge: Badge | undefined;
+    bindDirectiveInstance: Bind;
+    onAfterViewChecked(): void;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     */
+    badgeSize: _angular_core.InputSignal<BadgeSize | undefined>;
+    /**
+     * Size of the badge, valid options are "large" and "xlarge".
+     * @group Props
+     */
+    size: _angular_core.InputSignal<BadgeSize | undefined>;
+    /**
+     * Severity type of the badge.
+     * @group Props
+     */
+    severity: _angular_core.InputSignal<BadgeSeverity | undefined>;
+    /**
+     * Value to display inside the badge.
+     * @group Props
+     */
+    value: _angular_core.InputSignal<string | number | null | undefined>;
+    /**
+     * When specified, disables the component.
+     * @group Props
+     */
+    badgeDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    _componentStyle: BadgeStyle;
+    displayStyle: _angular_core.Signal<"none" | null>;
+    dataP: _angular_core.Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Badge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Badge, "p-badge", never, { "badgeSize": { "alias": "badgeSize"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "badgeDisabled": { "alias": "badgeDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.Bind; inputs: {}; outputs: {}; }]>;
+}
+declare class BadgeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<BadgeModule, never, [typeof Badge, typeof i2.SharedModule], [typeof Badge, typeof i2.SharedModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<BadgeModule>;
+}
+
+export { Badge, BadgeClasses, BadgeModule, BadgeStyle };

package/types/primenglab-base.d.ts

@@ -0,0 +1,58 @@
+import { UseStyle } from 'primenglab/usestyle';
+import * as i0 from '@angular/core';
+
+declare const _default: {
+    _loadedStyleNames: Set<unknown>;
+    getLoadedStyleNames(): any;
+    isStyleNameLoaded(name: any): any;
+    setLoadedStyleName(name: any): void;
+    deleteLoadedStyleName(name: any): void;
+    clearLoadedStyleNames(): void;
+};
+
+declare class BaseStyle {
+    name: string;
+    useStyle: UseStyle;
+    css: string | undefined;
+    style: any;
+    classes: {};
+    inlineStyles: {};
+    load: (style: any, options?: {}, transform?: (cs: any) => any) => {} | undefined;
+    loadCSS: (options?: {}) => {} | undefined;
+    loadStyle: (options?: any, style?: string) => {} | undefined;
+    loadBaseCSS: (options?: {}) => {} | undefined;
+    loadBaseStyle: (options?: any, style?: string) => {} | undefined;
+    getCommonTheme: (params?: any) => {
+        primitive: {
+            css: string | undefined;
+            tokens: any;
+        };
+        semantic: {
+            css: string | undefined;
+            tokens: any[] | undefined;
+        };
+        global: {
+            css: string | undefined;
+            tokens: any[] | undefined;
+        };
+        style: string | undefined;
+    };
+    getComponentTheme: (params: any) => {
+        css: string | undefined;
+        tokens: any[] | undefined;
+        style: string | undefined;
+    };
+    getPresetTheme: (preset: any, selector: any, params: any) => {
+        css: string | undefined;
+        tokens: any[] | undefined;
+        style: string | undefined;
+    };
+    getLayerOrderThemeCSS: () => string;
+    getStyleSheet: (extendedCSS?: string, props?: {}) => string;
+    getCommonThemeStyleSheet: (params: any, props?: {}) => any;
+    getThemeStyleSheet: (params: any, props?: {}) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseStyle, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseStyle>;
+}
+
+export { _default as Base, BaseStyle };

package/types/primenglab-basecomponent.d.ts

@@ -0,0 +1,178 @@
+import * as _angular_core from '@angular/core';
+import { ElementRef, Injector, ChangeDetectorRef, Renderer2, SimpleChanges, InjectionToken } from '@angular/core';
+import { cn } from '@primeuix/utils';
+import { Lifecycle, PassThroughOptions } from 'primenglab/api';
+import { BaseStyle } from 'primenglab/base';
+import { PrimeNG } from 'primenglab/config';
+
+declare class BaseComponentStyle extends BaseStyle {
+    name: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseComponentStyle, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BaseComponentStyle>;
+}
+
+declare const PARENT_INSTANCE: InjectionToken<BaseComponent<any>>;
+declare class BaseComponent<PT = any> implements Lifecycle {
+    document: Document;
+    platformId: any;
+    el: ElementRef;
+    readonly injector: Injector;
+    readonly cd: ChangeDetectorRef;
+    renderer: Renderer2;
+    config: PrimeNG;
+    $parentInstance: BaseComponent | undefined;
+    baseComponentStyle: BaseComponentStyle;
+    baseStyle: BaseStyle;
+    scopedStyleEl: any;
+    parent: {
+        instance: any;
+    };
+    protected readonly cn: typeof cn;
+    private _themeScopedListener;
+    private themeChangeListenerMap;
+    /******************** Inputs ********************/
+    /**
+     * Defines scoped design tokens of the component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    dt: _angular_core.InputSignal<Object | undefined>;
+    /**
+     * Indicates whether the component should be rendered without styles.
+     * @defaultValue undefined
+     * @group Props
+     */
+    unstyled: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Used to pass attributes to DOM elements inside the component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    pt: _angular_core.InputSignal<PT | undefined>;
+    /**
+     * Used to configure passthrough(pt) options of the component.
+     * @group Props
+     * @defaultValue undefined
+     */
+    ptOptions: _angular_core.InputSignal<PassThroughOptions | undefined>;
+    /******************** Computed ********************/
+    $attrSelector: string;
+    get $name(): any;
+    private get $hostName();
+    get $el(): any;
+    directivePT: _angular_core.WritableSignal<any>;
+    directiveUnstyled: _angular_core.WritableSignal<boolean | undefined>;
+    $unstyled: _angular_core.Signal<boolean>;
+    $pt: _angular_core.Signal<any>;
+    get $globalPT(): any;
+    get $defaultPT(): any;
+    private _$styleCache;
+    get $style(): any;
+    get $styleOptions(): {
+        nonce: string | undefined;
+    };
+    private _$paramsCache;
+    get $params(): {
+        instance: any;
+        parent: {
+            instance: any;
+        };
+    };
+    /******************** Lifecycle Hooks ********************/
+    onInit(): void;
+    onChanges(changes: SimpleChanges): void;
+    onDoCheck(): void;
+    onAfterContentInit(): void;
+    onAfterContentChecked(): void;
+    onAfterViewInit(): void;
+    onAfterViewChecked(): void;
+    onDestroy(): void;
+    /******************** Angular Lifecycle Hooks ********************/
+    constructor();
+    /**
+     * ⚠ Do not override ngOnInit!
+     *
+     * Use 'onInit()' in subclasses instead.
+     */
+    ngOnInit(): void;
+    /**
+     * ⚠ Do not override ngOnChanges!
+     *
+     * Use 'onChanges(changes: SimpleChanges)' in subclasses instead.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * ⚠ Do not override ngDoCheck!
+     *
+     * Use 'onDoCheck()' in subclasses instead.
+     */
+    ngDoCheck(): void;
+    /**
+     * ⚠ Do not override ngAfterContentInit!
+     *
+     * Use 'onAfterContentInit()' in subclasses instead.
+     */
+    ngAfterContentInit(): void;
+    /**
+     * ⚠ Do not override ngAfterContentChecked!
+     *
+     * Use 'onAfterContentChecked()' in subclasses instead.
+     */
+    ngAfterContentChecked(): void;
+    /**
+     * ⚠ Do not override ngAfterViewInit!
+     *
+     * Use 'onAfterViewInit()' in subclasses instead.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * ⚠ Do not override ngAfterViewChecked!
+     *
+     * Use 'onAfterViewChecked()' in subclasses instead.
+     */
+    ngAfterViewChecked(): void;
+    /**
+     * ⚠ Do not override ngOnDestroy!
+     *
+     * Use 'onDestroy()' in subclasses instead.
+     */
+    ngOnDestroy(): void;
+    /******************** Methods ********************/
+    private _mergeProps;
+    private _getHostInstance;
+    private _getPropValue;
+    private _getOptionValue;
+    private _hook;
+    /********** Load Styles **********/
+    private _load;
+    private _loadStyles;
+    private _loadGlobalStyles;
+    private _loadCoreStyles;
+    private _loadThemeStyles;
+    private _loadScopedThemeStyles;
+    private _unloadScopedThemeStyles;
+    private _themeChangeListener;
+    private _removeThemeListeners;
+    private _offThemeChangeListener;
+    /********** Passthrough **********/
+    private _getPTValue;
+    private _getPTDatasets;
+    private _getPTClassValue;
+    private _getPT;
+    private _usePT;
+    private _useGlobalPT;
+    private _useDefaultPT;
+    /******************** Exposed API ********************/
+    ptm(key?: string, params?: {}): any;
+    ptms(keys: string[], params?: {}): {};
+    ptmo(obj?: {}, key?: string, params?: {}): any;
+    cx(key: string, params?: {}): string | undefined;
+    sx(key?: string, when?: boolean, params?: {}): {
+        [x: string]: any;
+    } | undefined;
+    translate(key: string, subKey?: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseComponent<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseComponent<any>, never, never, { "dt": { "alias": "dt"; "required": false; "isSignal": true; }; "unstyled": { "alias": "unstyled"; "required": false; "isSignal": true; }; "pt": { "alias": "pt"; "required": false; "isSignal": true; }; "ptOptions": { "alias": "ptOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { BaseComponent, BaseComponentStyle, PARENT_INSTANCE };

package/types/primenglab-baseeditableholder.d.ts

@@ -0,0 +1,45 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BaseModelHolder } from 'primenglab/basemodelholder';
+
+declare class BaseEditableHolder<PT = any> extends BaseModelHolder<PT> implements ControlValueAccessor {
+    /**
+     * There must be a value (if set).
+     * @defaultValue false
+     * @group Props
+     */
+    required: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * When present, it specifies that the component should have invalid state style.
+     * @defaultValue false
+     * @group Props
+     */
+    invalid: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * When present, it specifies that the component should have disabled state style.
+     * @defaultValue false
+     * @group Props
+     */
+    disabled: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * When present, it specifies that the name of the input.
+     * @defaultValue undefined
+     * @group Props
+     */
+    name: _angular_core.InputSignal<string | undefined>;
+    _disabled: _angular_core.WritableSignal<boolean>;
+    $disabled: _angular_core.Signal<boolean>;
+    onModelChange: Function;
+    onModelTouched: Function;
+    writeDisabledState(value: boolean): void;
+    writeControlValue(value: any, setModelValue?: (value: any) => void): void;
+    /**** Angular ControlValueAccessors ****/
+    writeValue(value: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState(val: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseEditableHolder<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseEditableHolder<any>, never, never, { "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { BaseEditableHolder };

package/types/primenglab-baseinput.d.ts

@@ -0,0 +1,74 @@
+import * as _angular_core from '@angular/core';
+import { BaseEditableHolder } from 'primenglab/baseeditableholder';
+import { Fluid } from 'primenglab/fluid';
+
+declare class BaseInput<PT = any> extends BaseEditableHolder<PT> {
+    pcFluid: Fluid | null;
+    /**
+     * Spans 100% width of the container when enabled.
+     * @defaultValue false
+     * @group Props
+     */
+    fluid: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * Specifies the input variant of the component.
+     * @defaultValue 'outlined'
+     * @group Props
+     */
+    variant: _angular_core.InputSignal<"filled" | "outlined" | undefined>;
+    /**
+     * Specifies the size of the component.
+     * @defaultValue undefined
+     * @group Props
+     */
+    size: _angular_core.InputSignal<"large" | "small" | undefined>;
+    /**
+     * Specifies the visible width of the input element in characters.
+     * @defaultValue undefined
+     * @group Props
+     */
+    inputSize: _angular_core.InputSignal<number | null | undefined>;
+    /**
+     * Specifies the value must match the pattern.
+     * @defaultValue undefined
+     * @group Props
+     */
+    pattern: _angular_core.InputSignal<string | readonly RegExp[] | null | undefined>;
+    /**
+     * The value must be greater than or equal to the value.
+     * @defaultValue undefined
+     * @group Props
+     */
+    min: _angular_core.InputSignal<number | null | undefined>;
+    /**
+     * The value must be less than or equal to the value.
+     * @defaultValue undefined
+     * @group Props
+     */
+    max: _angular_core.InputSignal<number | null | undefined>;
+    /**
+     * Unless the step is set to the any literal, the value must be min + an integral multiple of the step.
+     * @defaultValue undefined
+     * @group Props
+     */
+    step: _angular_core.InputSignal<number | null | undefined>;
+    /**
+     * The number of characters (code points) must not be less than the value of the attribute, if non-empty.
+     * @defaultValue undefined
+     * @group Props
+     */
+    minlength: _angular_core.InputSignal<number | null | undefined>;
+    /**
+     * The number of characters (code points) must not exceed the value of the attribute.
+     * @defaultValue undefined
+     * @group Props
+     */
+    maxlength: _angular_core.InputSignal<number | null | undefined>;
+    $variant: _angular_core.Signal<"filled" | "outlined" | null>;
+    $pattern: _angular_core.Signal<string | undefined>;
+    get hasFluid(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseInput<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseInput<any>, never, never, { "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "inputSize": { "alias": "inputSize"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "minlength": { "alias": "minlength"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { BaseInput };