flowbite-angular 0.0.2 → 1.0.0-alpha.2

package/lib/components/dropdown/dropdown-item.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { DropdownItemClass, DropdownItemProperties, DropdownItemTheme } from './dropdown-item.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DROPDOWN_ITEM_THEME_TOKEN: InjectionToken<DropdownItemTheme>;
+export declare class DropdownItemThemeService implements FlowbiteThemeService<DropdownItemProperties> {
+    private readonly baseTheme;
+    getClasses(properties: DropdownItemProperties): DropdownItemClass;
+}

package/lib/components/dropdown/dropdown.component.d.ts

@@ -0,0 +1,71 @@
+import { BaseComponent } from '../base-component.directive';
+import { IconRegistry } from '../icon';
+import { DropdownDividerComponent } from './dropdown-divider.component';
+import { DropdownHeaderComponent } from './dropdown-header.component';
+import { DropdownItemComponent } from './dropdown-item.component';
+import type { DropdownClass, DropdownPositions } from './dropdown.theme';
+import { DropdownThemeService } from './dropdown.theme.service';
+import type { AfterViewInit } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import type { Placement } from '@floating-ui/dom';
+import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/dropdowns/
+ */
+export declare class DropdownComponent extends BaseComponent<DropdownClass> implements AfterViewInit {
+    dropdown: ElementRef;
+    button: ElementRef;
+    readonly themeService: DropdownThemeService;
+    readonly iconRegistry: IconRegistry;
+    readonly domSanitizer: DomSanitizer;
+    readonly dropdownItemChildren: import("@angular/core").Signal<readonly DropdownItemComponent[]>;
+    readonly dropdownHeaderChildren: import("@angular/core").Signal<readonly DropdownHeaderComponent[]>;
+    readonly dropdownDividerChildren: import("@angular/core").Signal<readonly DropdownDividerComponent[]>;
+    label: import("@angular/core").ModelSignal<string>;
+    isOpen: import("@angular/core").ModelSignal<boolean>;
+    position: import("@angular/core").ModelSignal<keyof DropdownPositions>;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+        } | undefined;
+        dropdown?: {
+            base?: string | undefined;
+        } | undefined;
+        span?: {
+            base?: string | undefined;
+        } | undefined;
+        container?: {
+            base?: string | undefined;
+            isOpen?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            placement?: {
+                'left-center'?: string | undefined;
+                'right-center'?: string | undefined;
+                'bottom-center'?: string | undefined;
+                'top-center'?: string | undefined;
+            } | undefined;
+        } | undefined;
+        content?: {
+            base?: string | undefined;
+        } | undefined;
+        subContent?: {
+            base?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): DropdownClass;
+    init(): void;
+    verify(): void;
+    x: number;
+    y: number;
+    width: number;
+    toggle(): void;
+    calculatePosition(): void;
+    ngAfterViewInit(): void;
+    clickout(event: Event): void;
+    convertPosition(pos: keyof DropdownPositions): Placement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "flowbite-dropdown", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "label": "labelChange"; "isOpen": "isOpenChange"; "position": "positionChange"; "customStyle": "customStyleChange"; }, ["dropdownItemChildren", "dropdownHeaderChildren", "dropdownDividerChildren"], ["*"], true, never>;
+}

package/lib/components/dropdown/dropdown.theme.d.ts

@@ -0,0 +1,44 @@
+import type { DeepPartial } from '../../common';
+import type { FlowbiteBoolean } from '../../common/type-definitions/flowbite.boolean';
+import type { FlowbiteClass } from '../../common/type-definitions/flowbite.class';
+import type { FlowbitePositions } from '../../common/type-definitions/flowbite.positions';
+export interface DropdownPositions extends Pick<FlowbitePositions, 'bottom-center' | 'top-center'> {
+    'left-center': string;
+    'right-center': string;
+}
+export interface DropdownProperties {
+    label: string;
+    isOpen: keyof FlowbiteBoolean;
+    placement: keyof DropdownPositions;
+    customStyle: DeepPartial<DropdownTheme>;
+}
+export interface DropdownTheme {
+    root: {
+        base: string;
+    };
+    dropdown: {
+        base: string;
+    };
+    span: {
+        base: string;
+    };
+    container: {
+        base: string;
+        isOpen: FlowbiteBoolean;
+        placement: DropdownPositions;
+    };
+    content: {
+        base: string;
+    };
+    subContent: {
+        base: string;
+    };
+}
+export declare const dropdownTheme: DropdownTheme;
+export interface DropdownClass extends FlowbiteClass {
+    dropdownClass: string;
+    spanClass: string;
+    containerClass: string;
+    contentClass: string;
+    subContentClass: string;
+}

package/lib/components/dropdown/dropdown.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { DropdownClass, DropdownProperties, DropdownTheme } from './dropdown.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DROPDOWN_THEME_TOKEN: InjectionToken<DropdownTheme>;
+export declare class DropdownThemeService implements FlowbiteThemeService<DropdownProperties> {
+    private readonly baseTheme;
+    getClasses(properties: DropdownProperties): DropdownClass;
+}

package/lib/components/dropdown/index.d.ts

@@ -0,0 +1,16 @@
+export { DropdownComponent } from './dropdown.component';
+export type { DropdownProperties, DropdownClass, DropdownPositions, DropdownTheme, } from './dropdown.theme';
+export { dropdownTheme } from './dropdown.theme';
+export { DropdownThemeService, FLOWBITE_DROPDOWN_THEME_TOKEN } from './dropdown.theme.service';
+export { DropdownItemComponent } from './dropdown-item.component';
+export type { DropdownItemProperties, DropdownItemClass, DropdownItemTheme, } from './dropdown-item.theme';
+export { dropdownItemTheme } from './dropdown-item.theme';
+export { DropdownItemThemeService, FLOWBITE_DROPDOWN_ITEM_THEME_TOKEN, } from './dropdown-item.theme.service';
+export { DropdownDividerComponent } from './dropdown-divider.component';
+export type { DropdownDividerProperties, DropdownDividerClass, DropdownDividerTheme, } from './dropdown-divider.theme';
+export { dropdownDividerTheme } from './dropdown-divider.theme';
+export { DropdownDividerThemeService, FLOWBITE_DROPDOWN_DIVIDER_THEME_TOKEN, } from './dropdown-divider.theme.service';
+export { DropdownHeaderComponent } from './dropdown-header.component';
+export type { DropdownHeaderProperties, DropdownHeaderClass, DropdownHeaderTheme, } from './dropdown-header.theme';
+export { dropdownHeaderTheme } from './dropdown-header.theme';
+export { DropdownHeaderThemeService, FLOWBITE_DROPDOWN_HEADER_THEME_TOKEN, } from './dropdown-header.theme.service';

package/lib/components/form-field/directives/addon.directive.d.ts

@@ -0,0 +1,13 @@
+import { AddonDirectiveThemeService } from './addon.directive.theme.service';
+import { BaseInputDirective } from './base-input.directive';
+import * as i0 from "@angular/core";
+export declare class AddonDirective extends BaseInputDirective {
+    protected contentClasses: import("@angular/core").WritableSignal<import("../../../common").FlowbiteClass>;
+    protected readonly themeService: AddonDirectiveThemeService;
+    customStyle: import("@angular/core").InputSignal<{
+        base?: string | undefined;
+    }>;
+    fetchClass(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AddonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AddonDirective, "[flowbiteAddon]", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/form-field/directives/addon.directive.theme.d.ts

@@ -0,0 +1,10 @@
+import type { DeepPartial, FlowbiteClass } from '../../../common';
+export interface AddonDirectiveProperties {
+    customStyle: DeepPartial<AddonDirectiveBaseTheme>;
+}
+export interface AddonDirectiveBaseTheme {
+    base: string;
+}
+export declare const addonDirectiveTheme: AddonDirectiveBaseTheme;
+export type AddonDirectiveClass = FlowbiteClass;
+export declare const addonDirectiveClassInstance: AddonDirectiveClass;

package/lib/components/form-field/directives/addon.directive.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../../services';
+import type { AddonDirectiveBaseTheme, AddonDirectiveClass, AddonDirectiveProperties } from './addon.directive.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DIRECTIVE_ADDON_THEME_TOKEN: InjectionToken<AddonDirectiveBaseTheme>;
+export declare class AddonDirectiveThemeService implements FlowbiteThemeService<AddonDirectiveProperties> {
+    private readonly baseTheme;
+    getClasses(properties: AddonDirectiveProperties): AddonDirectiveClass;
+}

package/lib/components/form-field/directives/base-input.directive.d.ts

@@ -0,0 +1,14 @@
+import type { FlowbiteClass } from '../../../common';
+import { FormFieldComponent } from '../form-field.component';
+import type { OnInit } from '@angular/core';
+import { Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare abstract class BaseInputDirective implements OnInit {
+    protected contentClasses: import("@angular/core").WritableSignal<FlowbiteClass>;
+    protected readonly injector: Injector;
+    protected readonly formFieldComponent: FormFieldComponent;
+    ngOnInit(): void;
+    abstract fetchClass(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseInputDirective, never, never, {}, {}, never, never, true, never>;
+}

package/lib/components/form-field/directives/helper.directive.d.ts

@@ -0,0 +1,18 @@
+import type { FlowbiteClass } from '../../../common';
+import { BaseInputDirective } from './base-input.directive';
+import { HelperDirectiveThemeService } from './helper.directive.theme.service';
+import * as i0 from "@angular/core";
+export declare class HelperDirective extends BaseInputDirective {
+    protected contentClasses: import("@angular/core").WritableSignal<FlowbiteClass>;
+    protected readonly themeService: HelperDirectiveThemeService;
+    customStyle: import("@angular/core").InputSignal<{
+        base?: string | undefined;
+        validation?: {
+            success?: string | undefined;
+            error?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): FlowbiteClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HelperDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HelperDirective, "[flowbiteHelper]", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/form-field/directives/helper.directive.theme.d.ts

@@ -0,0 +1,13 @@
+import type { DeepPartial, FlowbiteClass } from '../../../common';
+import type { FormFieldValidations } from '../form-field.theme';
+export interface HelperDirectiveProperties {
+    validate?: keyof FormFieldValidations;
+    customStyle: DeepPartial<HelperDirectiveBaseTheme>;
+}
+export interface HelperDirectiveBaseTheme {
+    base: string;
+    validation: FormFieldValidations;
+}
+export declare const helperDirectiveTheme: HelperDirectiveBaseTheme;
+export type HelperDirectiveClass = FlowbiteClass;
+export declare const helperDirectiveClassInstance: HelperDirectiveClass;

package/lib/components/form-field/directives/helper.directive.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../../services';
+import type { HelperDirectiveBaseTheme, HelperDirectiveClass, HelperDirectiveProperties } from './helper.directive.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DIRECTIVE_HELPER_THEME_TOKEN: InjectionToken<HelperDirectiveBaseTheme>;
+export declare class HelperDirectiveThemeService implements FlowbiteThemeService<HelperDirectiveProperties> {
+    private readonly baseTheme;
+    getClasses(properties: HelperDirectiveProperties): HelperDirectiveClass;
+}

package/lib/components/form-field/directives/icon.directive.d.ts

@@ -0,0 +1,13 @@
+import { BaseInputDirective } from './base-input.directive';
+import { IconDirectiveThemeService } from './icon.directive.theme.service';
+import * as i0 from "@angular/core";
+export declare class IconDirective extends BaseInputDirective {
+    protected contentClasses: import("@angular/core").WritableSignal<import("../../../common").FlowbiteClass>;
+    protected readonly themeService: IconDirectiveThemeService;
+    customStyle: import("@angular/core").InputSignal<{
+        base?: string | undefined;
+    }>;
+    fetchClass(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IconDirective, "[flowbiteIcon]", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/form-field/directives/icon.directive.theme.d.ts

@@ -0,0 +1,10 @@
+import type { DeepPartial, FlowbiteClass } from '../../../common';
+export interface IconDirectiveProperties {
+    customStyle: DeepPartial<IconDirectiveBaseTheme>;
+}
+export interface IconDirectiveBaseTheme {
+    base: string;
+}
+export declare const iconDirectiveTheme: IconDirectiveBaseTheme;
+export type IconDirectiveClass = FlowbiteClass;
+export declare const iconDirectiveClassInstance: IconDirectiveClass;

package/lib/components/form-field/directives/icon.directive.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../../services';
+import type { IconDirectiveBaseTheme, IconDirectiveClass, IconDirectiveProperties } from './icon.directive.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DIRECTIVE_ICON_THEME_TOKEN: InjectionToken<IconDirectiveBaseTheme>;
+export declare class IconDirectiveThemeService implements FlowbiteThemeService<IconDirectiveProperties> {
+    private readonly baseTheme;
+    getClasses(properties: IconDirectiveProperties): IconDirectiveClass;
+}

package/lib/components/form-field/directives/index.d.ts

@@ -0,0 +1,21 @@
+export { AddonDirective } from './addon.directive';
+export type { AddonDirectiveBaseTheme, AddonDirectiveClass, AddonDirectiveProperties, } from './addon.directive.theme';
+export { addonDirectiveClassInstance, addonDirectiveTheme } from './addon.directive.theme';
+export { AddonDirectiveThemeService, FLOWBITE_DIRECTIVE_ADDON_THEME_TOKEN, } from './addon.directive.theme.service';
+export { BaseInputDirective } from './base-input.directive';
+export { HelperDirective } from './helper.directive';
+export type { HelperDirectiveBaseTheme, HelperDirectiveClass, HelperDirectiveProperties, } from './helper.directive.theme';
+export { helperDirectiveClassInstance, helperDirectiveTheme } from './helper.directive.theme';
+export { FLOWBITE_DIRECTIVE_HELPER_THEME_TOKEN, HelperDirectiveThemeService, } from './helper.directive.theme.service';
+export { IconDirective } from './icon.directive';
+export type { IconDirectiveBaseTheme, IconDirectiveClass, IconDirectiveProperties, } from './icon.directive.theme';
+export { iconDirectiveClassInstance, iconDirectiveTheme } from './icon.directive.theme';
+export { FLOWBITE_DIRECTIVE_ICON_THEME_TOKEN, IconDirectiveThemeService, } from './icon.directive.theme.service';
+export { InputDirective } from './input.directive';
+export type { InputDirectiveBaseTheme, InputDirectiveClass, InputDirectiveProperties, } from './input.directive.theme';
+export { inputDirectiveClassInstance, inputDirectiveTheme } from './input.directive.theme';
+export { FLOWBITE_DIRECTIVE_INPUT_THEME_TOKEN, InputDirectiveThemeService, } from './input.directive.theme.service';
+export { LabelDirective } from './label.directive';
+export type { LabelDirectiveBaseTheme, LabelDirectiveClass, LabelDirectiveProperties, } from './label.directive.theme';
+export { labelDirectiveClassInstance, labelDirectiveTheme } from './label.directive.theme';
+export { FLOWBITE_DIRECTIVE_LABEL_THEME_TOKEN, LabelDirectiveThemeService, } from './label.directive.theme.service';

package/lib/components/form-field/directives/input.directive.d.ts

@@ -0,0 +1,100 @@
+import { BaseInputDirective } from './base-input.directive';
+import { InputDirectiveThemeService } from './input.directive.theme.service';
+import * as i0 from "@angular/core";
+export declare class InputDirective extends BaseInputDirective {
+    protected contentClasses: import("@angular/core").WritableSignal<import("../../../common").FlowbiteClass>;
+    protected readonly themeService: InputDirectiveThemeService;
+    customStyle: import("@angular/core").InputSignal<{
+        base?: string | undefined;
+        default?: string | undefined;
+        size?: {
+            [x: string]: string | undefined;
+            sm?: string | undefined;
+            md?: string | undefined;
+            lg?: string | undefined;
+        } | undefined;
+        disabled?: {
+            enabled?: string | undefined;
+            disabled?: string | undefined;
+        } | undefined;
+        validation?: {
+            success?: string | undefined;
+            error?: string | undefined;
+        } | undefined;
+        prefix?: {
+            addon?: string | undefined;
+            icon?: string | undefined;
+        } | undefined;
+        floatingLabel?: {
+            outline?: {
+                disabled?: {
+                    enabled?: string | undefined;
+                    disabled?: string | undefined;
+                } | undefined;
+                base?: string | undefined;
+                default?: string | undefined;
+                validation?: {
+                    success?: string | undefined;
+                    error?: string | undefined;
+                } | undefined;
+                size?: {
+                    [x: string]: string | undefined;
+                    sm?: string | undefined;
+                    md?: string | undefined;
+                    lg?: string | undefined;
+                } | undefined;
+                prefix?: {
+                    addon?: string | undefined;
+                    icon?: string | undefined;
+                } | undefined;
+            } | undefined;
+            standard?: {
+                disabled?: {
+                    enabled?: string | undefined;
+                    disabled?: string | undefined;
+                } | undefined;
+                base?: string | undefined;
+                default?: string | undefined;
+                validation?: {
+                    success?: string | undefined;
+                    error?: string | undefined;
+                } | undefined;
+                size?: {
+                    [x: string]: string | undefined;
+                    sm?: string | undefined;
+                    md?: string | undefined;
+                    lg?: string | undefined;
+                } | undefined;
+                prefix?: {
+                    addon?: string | undefined;
+                    icon?: string | undefined;
+                } | undefined;
+            } | undefined;
+            fill?: {
+                disabled?: {
+                    enabled?: string | undefined;
+                    disabled?: string | undefined;
+                } | undefined;
+                base?: string | undefined;
+                default?: string | undefined;
+                validation?: {
+                    success?: string | undefined;
+                    error?: string | undefined;
+                } | undefined;
+                size?: {
+                    [x: string]: string | undefined;
+                    sm?: string | undefined;
+                    md?: string | undefined;
+                    lg?: string | undefined;
+                } | undefined;
+                prefix?: {
+                    addon?: string | undefined;
+                    icon?: string | undefined;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputDirective, "input[flowbiteInput]", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/form-field/directives/input.directive.theme.d.ts

@@ -0,0 +1,24 @@
+import type { DeepPartial } from '../../../common';
+import type { FlowbiteBoolean } from '../../../common/type-definitions/flowbite.boolean';
+import type { FlowbiteClass } from '../../../common/type-definitions/flowbite.class';
+import type { FormFieldFloatingLabelTypes, FormFieldPrefixes, FormFieldSizes, FormFieldValidations } from '../form-field.theme';
+export interface InputDirectiveProperties {
+    size: keyof FormFieldSizes;
+    disabled: keyof FlowbiteBoolean;
+    validate?: keyof FormFieldValidations;
+    floatingLabelType?: keyof FormFieldFloatingLabelTypes;
+    prefix?: keyof FormFieldPrefixes;
+    customStyle: DeepPartial<InputDirectiveBaseTheme>;
+}
+export interface InputDirectiveBaseTheme {
+    base: string;
+    default: string;
+    size: FormFieldSizes;
+    disabled: FlowbiteBoolean;
+    validation: FormFieldValidations;
+    prefix?: FormFieldPrefixes;
+    floatingLabel: Record<keyof FormFieldFloatingLabelTypes, Omit<InputDirectiveBaseTheme, 'floatingLabel'>>;
+}
+export declare const inputDirectiveTheme: InputDirectiveBaseTheme;
+export type InputDirectiveClass = FlowbiteClass;
+export declare const inputDirectiveClassInstance: InputDirectiveClass;

package/lib/components/form-field/directives/input.directive.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../../services';
+import type { InputDirectiveBaseTheme, InputDirectiveClass, InputDirectiveProperties } from './input.directive.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DIRECTIVE_INPUT_THEME_TOKEN: InjectionToken<InputDirectiveBaseTheme>;
+export declare class InputDirectiveThemeService implements FlowbiteThemeService<InputDirectiveProperties> {
+    private readonly baseTheme;
+    getClasses(properties: InputDirectiveProperties): InputDirectiveClass;
+}

package/lib/components/form-field/directives/label.directive.d.ts

@@ -0,0 +1,62 @@
+import { FormFieldComponent } from '../form-field.component';
+import { BaseInputDirective } from './base-input.directive';
+import { LabelDirectiveThemeService } from './label.directive.theme.service';
+import * as i0 from "@angular/core";
+export declare class LabelDirective extends BaseInputDirective {
+    protected contentClasses: import("@angular/core").WritableSignal<import("../../../common").FlowbiteClass>;
+    protected readonly themeService: LabelDirectiveThemeService;
+    protected readonly for: FormFieldComponent;
+    customStyle: import("@angular/core").InputSignal<{
+        base?: string | undefined;
+        default?: string | undefined;
+        disabled?: {
+            enabled?: string | undefined;
+            disabled?: string | undefined;
+        } | undefined;
+        validation?: {
+            success?: string | undefined;
+            error?: string | undefined;
+        } | undefined;
+        floatingLabel?: {
+            outline?: {
+                disabled?: {
+                    enabled?: string | undefined;
+                    disabled?: string | undefined;
+                } | undefined;
+                base?: string | undefined;
+                default?: string | undefined;
+                validation?: {
+                    success?: string | undefined;
+                    error?: string | undefined;
+                } | undefined;
+            } | undefined;
+            standard?: {
+                disabled?: {
+                    enabled?: string | undefined;
+                    disabled?: string | undefined;
+                } | undefined;
+                base?: string | undefined;
+                default?: string | undefined;
+                validation?: {
+                    success?: string | undefined;
+                    error?: string | undefined;
+                } | undefined;
+            } | undefined;
+            fill?: {
+                disabled?: {
+                    enabled?: string | undefined;
+                    disabled?: string | undefined;
+                } | undefined;
+                base?: string | undefined;
+                default?: string | undefined;
+                validation?: {
+                    success?: string | undefined;
+                    error?: string | undefined;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LabelDirective, "label[flowbiteLabel]", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/components/form-field/directives/label.directive.theme.d.ts

@@ -0,0 +1,20 @@
+import type { DeepPartial } from '../../../common';
+import type { FlowbiteBoolean } from '../../../common/type-definitions/flowbite.boolean';
+import type { FlowbiteClass } from '../../../common/type-definitions/flowbite.class';
+import type { FormFieldFloatingLabelTypes, FormFieldValidations } from '../form-field.theme';
+export interface LabelDirectiveProperties {
+    disabled: keyof FlowbiteBoolean;
+    validate?: keyof FormFieldValidations;
+    floatingLabelType?: keyof FormFieldFloatingLabelTypes;
+    customStyle: DeepPartial<LabelDirectiveBaseTheme>;
+}
+export interface LabelDirectiveBaseTheme {
+    base: string;
+    default: string;
+    disabled?: FlowbiteBoolean;
+    validation: FormFieldValidations;
+    floatingLabel: Record<keyof FormFieldFloatingLabelTypes, Omit<LabelDirectiveBaseTheme, 'floatingLabel'>>;
+}
+export declare const labelDirectiveTheme: LabelDirectiveBaseTheme;
+export type LabelDirectiveClass = FlowbiteClass;
+export declare const labelDirectiveClassInstance: LabelDirectiveClass;

package/lib/components/form-field/directives/label.directive.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../../services';
+import type { LabelDirectiveBaseTheme, LabelDirectiveClass, LabelDirectiveProperties } from './label.directive.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DIRECTIVE_LABEL_THEME_TOKEN: InjectionToken<LabelDirectiveBaseTheme>;
+export declare class LabelDirectiveThemeService implements FlowbiteThemeService<LabelDirectiveProperties> {
+    private readonly baseTheme;
+    getClasses(properties: LabelDirectiveProperties): LabelDirectiveClass;
+}

package/lib/components/form-field/form-field.component.d.ts

@@ -0,0 +1,20 @@
+import { BaseComponent } from '../base-component.directive';
+import type * as properties from './form-field.theme';
+import { FormFieldThemeService } from './form-field.theme.service';
+import type { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FormFieldComponent extends BaseComponent<properties.FormFieldClass> implements OnInit {
+    readonly themeService: FormFieldThemeService;
+    type: import("@angular/core").ModelSignal<keyof properties.FormFieldTypes>;
+    size: import("@angular/core").ModelSignal<keyof properties.FormFieldSizes>;
+    isDisabled: import("@angular/core").ModelSignal<boolean>;
+    validate: import("@angular/core").ModelSignal<keyof properties.FormFieldValidations | undefined>;
+    floatingLabelType: import("@angular/core").ModelSignal<keyof properties.FormFieldFloatingLabelTypes | undefined>;
+    prefix: import("@angular/core").ModelSignal<keyof properties.FormFieldPrefixes | undefined>;
+    customStyle: import("@angular/core").ModelSignal<{
+        base?: string | undefined;
+    }>;
+    fetchClass(): properties.FormFieldClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "flowbite-form-field", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "validate": { "alias": "validate"; "required": false; "isSignal": true; }; "floatingLabelType": { "alias": "floatingLabelType"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "type": "typeChange"; "size": "sizeChange"; "isDisabled": "isDisabledChange"; "validate": "validateChange"; "floatingLabelType": "floatingLabelTypeChange"; "prefix": "prefixChange"; "customStyle": "customStyleChange"; }, never, ["input[flowbiteInput]", "label[flowbiteLabel]", "[flowbiteHelper]", "[flowbiteIcon]", "[flowbiteAddon]"], true, never>;
+}

package/lib/components/form-field/form-field.theme.d.ts

@@ -0,0 +1,45 @@
+import type { DeepPartial } from '../../common';
+import type { FlowbiteBoolean } from '../../common/type-definitions/flowbite.boolean';
+import type { FlowbiteClass } from '../../common/type-definitions/flowbite.class';
+import type { FlowbiteSizes } from '../../common/type-definitions/flowbite.sizes';
+export interface FormFieldTypes {
+    email: string;
+    password: string;
+    file: string;
+    number: string;
+    search: string;
+    tel: string;
+    text: string;
+    url: string;
+}
+export interface FormFieldFloatingLabelTypes {
+    standard: string;
+    fill: string;
+    outline: string;
+}
+export interface FormFieldValidations {
+    success: string;
+    error: string;
+}
+export interface FormFieldPrefixes {
+    addon: string;
+    icon: string;
+}
+export interface FormFieldSizes extends Pick<FlowbiteSizes, 'sm' | 'md' | 'lg'> {
+    [key: string]: string;
+}
+export interface FormFieldProperties {
+    type: keyof FormFieldTypes;
+    floatingLabelType?: keyof FormFieldFloatingLabelTypes;
+    size: keyof FormFieldSizes;
+    disabled: keyof FlowbiteBoolean;
+    validate?: keyof FormFieldValidations;
+    prefix?: keyof FormFieldPrefixes;
+    customStyle: DeepPartial<FormFieldBaseTheme>;
+}
+export interface FormFieldBaseTheme {
+    base: string;
+}
+export declare const formFieldTheme: FormFieldBaseTheme;
+export type FormFieldClass = FlowbiteClass;
+export declare const FormFieldClassInstance: FormFieldClass;

package/lib/components/form-field/form-field.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { FormFieldBaseTheme, FormFieldClass, FormFieldProperties } from './form-field.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_FORM_FIELD_THEME_TOKEN: InjectionToken<FormFieldBaseTheme>;
+export declare class FormFieldThemeService implements FlowbiteThemeService<FormFieldProperties> {
+    private readonly baseTheme;
+    getClasses(properties: FormFieldProperties): FormFieldClass;
+}

package/lib/components/form-field/index.d.ts

@@ -0,0 +1,5 @@
+export * from './directives';
+export { FormFieldComponent } from './form-field.component';
+export type { FormFieldProperties, FormFieldFloatingLabelTypes, FormFieldPrefixes, FormFieldSizes, FormFieldTypes, FormFieldValidations, FormFieldClass, FormFieldBaseTheme, } from './form-field.theme';
+export { FormFieldClassInstance, formFieldTheme } from './form-field.theme';
+export { FormFieldThemeService, FLOWBITE_FORM_FIELD_THEME_TOKEN } from './form-field.theme.service';