flowbite-angular 0.0.2 → 1.0.0-alpha.1

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

@@ -1,13 +1,53 @@
+import { FlowbiteRouterLinkDirective } from '../../directives/flowbite-router-link.directive';
+import { BaseComponent } from '../base-component.directive';
+import type { BadgeClass, BadgeColors, BadgeSizes } from './badge.theme';
+import { BadgeThemeService } from './badge.theme.service';
 import * as i0 from "@angular/core";
-export declare type BadgeColor = 'blue' | 'dark' | 'red' | 'green' | 'yellow' | 'indigo' | 'purple' | 'pink';
-export declare type BadgeSize = 'xs' | 'sm';
-export declare class BadgeComponent {
-    color: BadgeColor;
-    size: BadgeSize;
-    href?: string;
-    iconOnly: boolean;
-    colorClasses: Record<BadgeColor, string>;
-    sizeClasses: Record<BadgeSize, string>;
+/**
+ * @see https://flowbite.com/docs/components/badge/
+ */
+export declare class BadgeComponent extends BaseComponent<BadgeClass> {
+    readonly flowbiteRouterLink: FlowbiteRouterLinkDirective | null;
+    readonly themeService: BadgeThemeService;
+    color: import("@angular/core").ModelSignal<keyof BadgeColors>;
+    size: import("@angular/core").ModelSignal<keyof BadgeSizes>;
+    isIconOnly: import("@angular/core").ModelSignal<boolean>;
+    isPill: import("@angular/core").ModelSignal<boolean>;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+            color?: {
+                [x: string]: string | undefined;
+                primary?: string | undefined;
+                blue?: string | undefined;
+                red?: string | undefined;
+                green?: string | undefined;
+                yellow?: string | undefined;
+                dark?: string | undefined;
+                indigo?: string | undefined;
+                pink?: string | undefined;
+                purple?: string | undefined;
+            } | undefined;
+            size?: {
+                [x: string]: string | undefined;
+                xs?: string | undefined;
+                sm?: string | undefined;
+            } | undefined;
+            isPill?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            isIconOnly?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            link?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): BadgeClass;
     static ɵfac: i0.ɵɵFactoryDeclaration<BadgeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "flowbite-badge", never, { "color": "color"; "size": "size"; "href": "href"; "iconOnly": "iconOnly"; }, {}, never, ["*"]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BadgeComponent, "flowbite-badge", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "isIconOnly": { "alias": "isIconOnly"; "required": false; "isSignal": true; }; "isPill": { "alias": "isPill"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "color": "colorChange"; "size": "sizeChange"; "isIconOnly": "isIconOnlyChange"; "isPill": "isPillChange"; "customStyle": "customStyleChange"; }, never, ["*"], true, never>;
 }

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

@@ -0,0 +1,32 @@
+import type { FlowbiteColors } from '../../common/type-definitions/colors/flowbite.colors';
+import type { FlowbiteBoolean } from '../../common/type-definitions/flowbite.boolean';
+import type { FlowbiteClass } from '../../common/type-definitions/flowbite.class';
+import type { DeepPartial } from '../../common/type-definitions/flowbite.deep-partial';
+import type { RouterLinkParameter } from '../../common/type-definitions/flowbite.router-link-parameter';
+import type { FlowbiteSizes } from '../../common/type-definitions/flowbite.sizes';
+export interface BadgeColors extends Pick<FlowbiteColors, 'primary' | 'dark' | 'blue' | 'red' | 'green' | 'yellow' | 'indigo' | 'purple' | 'pink'> {
+    [key: string]: string;
+}
+export interface BadgeSizes extends Pick<FlowbiteSizes, 'xs' | 'sm'> {
+    [key: string]: string;
+}
+export interface BadgeProperties {
+    color: keyof BadgeColors;
+    size: keyof BadgeSizes;
+    isIconOnly: keyof FlowbiteBoolean;
+    isPill: keyof FlowbiteBoolean;
+    link: RouterLinkParameter;
+    customStyle: DeepPartial<BadgeTheme>;
+}
+export interface BadgeTheme {
+    root: {
+        base: string;
+        color: BadgeColors;
+        size: BadgeSizes;
+        isPill: FlowbiteBoolean;
+        isIconOnly: FlowbiteBoolean;
+        link: FlowbiteBoolean;
+    };
+}
+export declare const badgeTheme: BadgeTheme;
+export type BadgeClass = FlowbiteClass;

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { BadgeClass, BadgeProperties, BadgeTheme } from './badge.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_BADGE_THEME_TOKEN: InjectionToken<BadgeTheme>;
+export declare class BadgeThemeService implements FlowbiteThemeService<BadgeProperties> {
+    private readonly baseTheme;
+    getClasses(properties: BadgeProperties): BadgeClass;
+}

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

@@ -1 +1,4 @@
-export * from './badge.component';
+export { BadgeComponent } from './badge.component';
+export type { BadgeProperties, BadgeClass, BadgeColors, BadgeSizes, BadgeTheme } from './badge.theme';
+export { badgeTheme } from './badge.theme';
+export { BadgeThemeService, FLOWBITE_BADGE_THEME_TOKEN } from './badge.theme.service';

package/lib/components/base-component.directive.d.ts

@@ -0,0 +1,19 @@
+import type { FlowbiteClass } from '../common';
+import { Guid } from '../utils/id.generator';
+import type { OnInit } from '@angular/core';
+import { Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare abstract class BaseComponent<TClass extends FlowbiteClass> implements OnInit {
+    readonly injector: Injector;
+    readonly flowbiteId: import("@angular/core").WritableSignal<Guid>;
+    contentClasses: import("@angular/core").Signal<TClass>;
+    ngOnInit(): void;
+    init(): void;
+    verify(): void;
+    /**
+     * Function to load component's classes
+     */
+    abstract fetchClass(): TClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseComponent<any>, never, never, {}, {}, never, never, true, never>;
+}

package/lib/components/breadcrumb/breadcrumb-item.component.d.ts

@@ -0,0 +1,39 @@
+import { FlowbiteRouterLinkDirective } from '../../directives/flowbite-router-link.directive';
+import { BaseComponent } from '../base-component.directive';
+import { IconRegistry } from '../icon';
+import type { BreadcrumbItemClass } from './breadcrumb-item.theme';
+import { BreadcrumbItemThemeService } from './breadcrumb-item.theme.service';
+import { BreadcrumbComponent } from './breadcrumb.component';
+import type { BreadcrumbColors } from './breadcrumb.theme';
+import type { OnInit } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class BreadcrumbItemComponent extends BaseComponent<BreadcrumbItemClass> implements OnInit {
+    readonly themeService: BreadcrumbItemThemeService;
+    readonly breadcrumbComponent: BreadcrumbComponent;
+    readonly flowbiteRouterLink: FlowbiteRouterLinkDirective | null;
+    readonly iconRegistry: IconRegistry;
+    readonly domSanitizer: DomSanitizer;
+    color: import("@angular/core").ModelSignal<keyof BreadcrumbColors>;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+            color?: {
+                [x: string]: string | undefined;
+                primary?: string | undefined;
+                blue?: string | undefined;
+                red?: string | undefined;
+                green?: string | undefined;
+                yellow?: string | undefined;
+                dark?: string | undefined;
+            } | undefined;
+        } | undefined;
+        icon?: {
+            base?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): BreadcrumbItemClass;
+    init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbItemComponent, "flowbite-breadcrumb-item", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "color": "colorChange"; "customStyle": "customStyleChange"; }, never, ["*"], true, never>;
+}

package/lib/components/breadcrumb/breadcrumb-item.theme.d.ts

@@ -0,0 +1,22 @@
+import type { FlowbiteClass } from '../../common/type-definitions/flowbite.class';
+import type { DeepPartial } from '../../common/type-definitions/flowbite.deep-partial';
+import type { BreadcrumbColors } from './breadcrumb.theme';
+import type { UrlTree } from '@angular/router';
+export interface BreadcrumbItemProperties {
+    color: keyof BreadcrumbColors;
+    link: UrlTree | null;
+    customStyle: DeepPartial<BreadcrumbItemTheme>;
+}
+export interface BreadcrumbItemTheme {
+    root: {
+        base: string;
+        color: BreadcrumbColors;
+    };
+    icon: {
+        base: string;
+    };
+}
+export declare const breadcrumbItemTheme: BreadcrumbItemTheme;
+export interface BreadcrumbItemClass extends FlowbiteClass {
+    breadcrumbIconClass: string;
+}

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { BreadcrumbItemClass, BreadcrumbItemProperties, BreadcrumbItemTheme } from './breadcrumb-item.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_BREADCRUMB_ITEM_THEME_TOKEN: InjectionToken<BreadcrumbItemTheme>;
+export declare class BreadcrumbItemThemeService implements FlowbiteThemeService<BreadcrumbItemProperties> {
+    private readonly baseTheme;
+    getClasses(properties: BreadcrumbItemProperties): BreadcrumbItemClass;
+}

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

@@ -0,0 +1,22 @@
+import { BaseComponent } from '../base-component.directive';
+import { BreadcrumbItemComponent } from './breadcrumb-item.component';
+import type { BreadcrumbClass, BreadcrumbColors } from './breadcrumb.theme';
+import { BreadcrumbThemeService } from './breadcrumb.theme.service';
+import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/breadcrumb/
+ */
+export declare class BreadcrumbComponent extends BaseComponent<BreadcrumbClass> {
+    readonly themeService: BreadcrumbThemeService;
+    readonly breadcrumbItemChildren: import("@angular/core").Signal<readonly BreadcrumbItemComponent[]>;
+    color: import("@angular/core").ModelSignal<keyof BreadcrumbColors>;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): BreadcrumbClass;
+    verify(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "flowbite-breadcrumb", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "color": "colorChange"; "customStyle": "customStyleChange"; }, ["breadcrumbItemChildren"], ["*"], true, never>;
+}

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

@@ -0,0 +1,14 @@
+import type { DeepPartial, FlowbiteClass, FlowbiteColors } from '../../common';
+export interface BreadcrumbColors extends Pick<FlowbiteColors, 'primary' | 'dark' | 'blue' | 'red' | 'green' | 'yellow'> {
+    [key: string]: string;
+}
+export interface BreadcrumbProperties {
+    customStyle: DeepPartial<BreadcrumbTheme>;
+}
+export interface BreadcrumbTheme {
+    root: {
+        base: string;
+    };
+}
+export declare const breadcrumbTheme: BreadcrumbTheme;
+export type BreadcrumbClass = FlowbiteClass;

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { BreadcrumbClass, BreadcrumbProperties, BreadcrumbTheme } from './breadcrumb.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_BREADCRUMB_THEME_TOKEN: InjectionToken<BreadcrumbTheme>;
+export declare class BreadcrumbThemeService implements FlowbiteThemeService<BreadcrumbProperties> {
+    private readonly baseTheme;
+    getClasses(properties: BreadcrumbProperties): BreadcrumbClass;
+}

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

@@ -0,0 +1,8 @@
+export { BreadcrumbComponent } from './breadcrumb.component';
+export type { BreadcrumbProperties, BreadcrumbClass, BreadcrumbTheme, BreadcrumbColors } from './breadcrumb.theme';
+export { breadcrumbTheme } from './breadcrumb.theme';
+export { BreadcrumbThemeService, FLOWBITE_BREADCRUMB_THEME_TOKEN } from './breadcrumb.theme.service';
+export { BreadcrumbItemComponent } from './breadcrumb-item.component';
+export type { BreadcrumbItemProperties, BreadcrumbItemClass, BreadcrumbItemTheme } from './breadcrumb-item.theme';
+export { breadcrumbItemTheme } from './breadcrumb-item.theme';
+export { BreadcrumbItemThemeService, FLOWBITE_BREADCRUMB_ITEM_THEME_TOKEN } from './breadcrumb-item.theme.service';

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

@@ -0,0 +1,110 @@
+import { BaseComponent } from '../base-component.directive';
+import type { ButtonClass, ButtonColors, ButtonFill, ButtonMonochromeColors, ButtonSizes } from './button.theme';
+import { ButtonThemeService } from './button.theme.service';
+import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/buttons/
+ */
+export declare class ButtonComponent extends BaseComponent<ButtonClass> {
+    readonly themeService: ButtonThemeService;
+    color: import("@angular/core").ModelSignal<keyof ButtonColors>;
+    size: import("@angular/core").ModelSignal<keyof ButtonSizes>;
+    isPill: import("@angular/core").ModelSignal<boolean>;
+    fill: import("@angular/core").ModelSignal<keyof ButtonFill>;
+    isDisabled: import("@angular/core").ModelSignal<boolean>;
+    gradientMonochrome: import("@angular/core").ModelSignal<keyof ButtonMonochromeColors | undefined>;
+    gradientDuoTone: import("@angular/core").ModelSignal<"purpleToBlue" | "cyanToBlue" | "greenToBlue" | "purpleToPink" | "pinkToOrange" | "tealToLime" | "redToYellow" | undefined>;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: {
+                default?: string | undefined;
+                span?: string | undefined;
+            } | undefined;
+            color?: {
+                [x: string]: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+                [x: number]: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+            } | undefined;
+            gradientMonochrome?: {
+                [x: string]: string | undefined;
+                blue?: string | undefined;
+                red?: string | undefined;
+                green?: string | undefined;
+                cyan?: string | undefined;
+                lime?: string | undefined;
+                pink?: string | undefined;
+                purple?: string | undefined;
+                teal?: string | undefined;
+            } | undefined;
+            gradientDuoTone?: {
+                purpleToBlue?: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+                cyanToBlue?: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+                greenToBlue?: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+                purpleToPink?: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+                pinkToOrange?: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+                tealToLime?: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+                redToYellow?: {
+                    solid?: string | undefined;
+                    outline?: string | undefined;
+                } | undefined;
+            } | undefined;
+            size?: {
+                [x: string]: string | undefined;
+                xs?: string | undefined;
+                sm?: string | undefined;
+                md?: string | undefined;
+                lg?: string | undefined;
+                xl?: string | undefined;
+            } | undefined;
+            isPill?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            isDisabled?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+        } | undefined;
+        span?: {
+            base?: string | undefined;
+            isPill?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            size?: {
+                [x: string]: string | undefined;
+                xs?: string | undefined;
+                sm?: string | undefined;
+                md?: string | undefined;
+                lg?: string | undefined;
+                xl?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): ButtonClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "flowbite-button", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "isPill": { "alias": "isPill"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "gradientMonochrome": { "alias": "gradientMonochrome"; "required": false; "isSignal": true; }; "gradientDuoTone": { "alias": "gradientDuoTone"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "color": "colorChange"; "size": "sizeChange"; "isPill": "isPillChange"; "fill": "fillChange"; "isDisabled": "isDisabledChange"; "gradientMonochrome": "gradientMonochromeChange"; "gradientDuoTone": "gradientDuoToneChange"; "customStyle": "customStyleChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,56 @@
+import type { FlowbiteColors } from '../../common/type-definitions/colors/flowbite.colors';
+import type { FlowbiteGradientColors } from '../../common/type-definitions/colors/flowbite.gradient-colors';
+import type { FlowbiteGradientDuoToneColors } from '../../common/type-definitions/colors/flowbite.gradient-duo-tone-colors';
+import type { FlowbiteBoolean } from '../../common/type-definitions/flowbite.boolean';
+import type { FlowbiteClass } from '../../common/type-definitions/flowbite.class';
+import type { Combination } from '../../common/type-definitions/flowbite.combination';
+import type { DeepPartial } from '../../common/type-definitions/flowbite.deep-partial';
+import type { FlowbiteSizes } from '../../common/type-definitions/flowbite.sizes';
+export interface ButtonColors extends Pick<FlowbiteColors, 'dark' | 'primary' | 'light' | 'blue' | 'red' | 'green' | 'yellow' | 'purple'> {
+    [key: string]: string;
+}
+export interface ButtonMonochromeColors extends Pick<FlowbiteGradientColors, 'blue' | 'green' | 'cyan' | 'teal' | 'lime' | 'red' | 'pink' | 'purple'> {
+    [key: string]: string;
+}
+export type ButtonDuoToneColors = Pick<FlowbiteGradientDuoToneColors, 'purpleToBlue' | 'cyanToBlue' | 'greenToBlue' | 'purpleToPink' | 'pinkToOrange' | 'tealToLime' | 'redToYellow'>;
+export interface ButtonSizes extends Pick<FlowbiteSizes, 'xs' | 'sm' | 'md' | 'lg' | 'xl'> {
+    [key: string]: string;
+}
+export interface ButtonFill {
+    solid: string;
+    outline: string;
+}
+export interface ButtonTypes {
+    default: string;
+    span: string;
+}
+export interface ButtonProperties {
+    color: keyof ButtonColors;
+    gradientMonochrome?: keyof ButtonMonochromeColors;
+    gradientDuoTone?: keyof ButtonDuoToneColors;
+    size: keyof ButtonSizes;
+    isPill: keyof FlowbiteBoolean;
+    fill: keyof ButtonFill;
+    isDisabled: keyof FlowbiteBoolean;
+    customStyle: DeepPartial<ButtonTheme>;
+}
+export interface ButtonTheme {
+    root: {
+        base: ButtonTypes;
+        color: Combination<keyof ButtonColors, keyof ButtonFill, string>;
+        gradientMonochrome: ButtonMonochromeColors;
+        gradientDuoTone: Combination<keyof ButtonDuoToneColors, keyof ButtonFill, string>;
+        size: ButtonSizes;
+        isPill: FlowbiteBoolean;
+        isDisabled: FlowbiteBoolean;
+    };
+    span: {
+        base: string;
+        isPill: FlowbiteBoolean;
+        size: ButtonSizes;
+    };
+}
+export declare const buttonTheme: ButtonTheme;
+export interface ButtonClass extends FlowbiteClass {
+    spanClass: string;
+}

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { ButtonClass, ButtonProperties, ButtonTheme } from './button.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_BUTTON_THEME_TOKEN: InjectionToken<ButtonTheme>;
+export declare class ButtonThemeService implements FlowbiteThemeService<ButtonProperties> {
+    private readonly baseTheme;
+    getClasses(properties: ButtonProperties): ButtonClass;
+}

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

@@ -0,0 +1,4 @@
+export { ButtonComponent } from './button.component';
+export type { ButtonProperties, ButtonClass, ButtonTypes, ButtonColors, ButtonDuoToneColors, ButtonFill, ButtonMonochromeColors, ButtonSizes, ButtonTheme, } from './button.theme';
+export { buttonTheme } from './button.theme';
+export { ButtonThemeService, FLOWBITE_BUTTON_THEME_TOKEN } from './button.theme.service';

package/lib/components/dark-theme-toggle/dark-theme-toggle.component.d.ts

@@ -1,12 +1,24 @@
-import { OnDestroy, OnInit } from '@angular/core';
-import { ThemeService } from '../../services';
+import { GlobalSignalStoreService } from '../../services';
+import type { ThemeState } from '../../services/state/theme.state';
+import { BaseComponent } from '../base-component.directive';
+import { IconRegistry } from '../icon';
+import type { DarkThemeToggleClass } from './dark-theme-toggle.theme';
+import { DarkThemeToggleThemeService } from './dark-theme-toggle.theme.service';
+import { DomSanitizer } from '@angular/platform-browser';
 import * as i0 from "@angular/core";
-export declare class DarkThemeToggleComponent implements OnInit, OnDestroy {
-    readonly themeService: ThemeService;
-    private themeSubscription;
-    constructor(themeService: ThemeService);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+export declare class DarkThemeToggleComponent extends BaseComponent<DarkThemeToggleClass> {
+    readonly themeService: DarkThemeToggleThemeService;
+    readonly themeStateService: GlobalSignalStoreService<ThemeState>;
+    readonly iconRegistry: IconRegistry;
+    readonly domSanitizer: DomSanitizer;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): DarkThemeToggleClass;
+    init(): void;
+    onClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DarkThemeToggleComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DarkThemeToggleComponent, "flowbite-dark-theme-toggle", never, {}, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DarkThemeToggleComponent, "flowbite-dark-theme-toggle", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "customStyle": "customStyleChange"; }, never, never, true, never>;
 }

package/lib/components/dark-theme-toggle/dark-theme-toggle.theme.d.ts

@@ -0,0 +1,11 @@
+import type { DeepPartial, FlowbiteClass } from '../../common';
+export interface DarkThemeToggleProperties {
+    customStyle: DeepPartial<DarkThemeToggleTheme>;
+}
+export interface DarkThemeToggleTheme {
+    root: {
+        base: string;
+    };
+}
+export declare const darkThemeToggleTheme: DarkThemeToggleTheme;
+export type DarkThemeToggleClass = FlowbiteClass;

package/lib/components/dark-theme-toggle/dark-theme-toggle.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { DarkThemeToggleClass, DarkThemeToggleProperties, DarkThemeToggleTheme } from './dark-theme-toggle.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DARK_THEME_TOGGLE_THEME_TOKEN: InjectionToken<DarkThemeToggleTheme>;
+export declare class DarkThemeToggleThemeService implements FlowbiteThemeService<DarkThemeToggleProperties> {
+    private readonly baseTheme;
+    getClasses(properties: DarkThemeToggleProperties): DarkThemeToggleClass;
+}

package/lib/components/dark-theme-toggle/index.d.ts

@@ -1 +1,4 @@
-export * from './dark-theme-toggle.component';
+export { DarkThemeToggleComponent } from './dark-theme-toggle.component';
+export type { DarkThemeToggleProperties, DarkThemeToggleClass, DarkThemeToggleTheme } from './dark-theme-toggle.theme';
+export { darkThemeToggleTheme } from './dark-theme-toggle.theme';
+export { DarkThemeToggleThemeService, FLOWBITE_DARK_THEME_TOGGLE_THEME_TOKEN } from './dark-theme-toggle.theme.service';

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

@@ -0,0 +1,13 @@
+import { BaseComponent } from '../base-component.directive';
+import type { DropdownDividerClass, DropdownDividerTheme } from './dropdown-divider.theme';
+import { DropdownDividerThemeService } from './dropdown-divider.theme.service';
+import { DropdownComponent } from './dropdown.component';
+import * as i0 from "@angular/core";
+export declare class DropdownDividerComponent extends BaseComponent<DropdownDividerClass> {
+    readonly themeService: DropdownDividerThemeService;
+    readonly dropdownComponent: DropdownComponent;
+    customStyle: import("@angular/core").ModelSignal<Partial<DropdownDividerTheme>>;
+    fetchClass(): DropdownDividerClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDividerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownDividerComponent, "flowbite-dropdown-divider", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "customStyle": "customStyleChange"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,11 @@
+import type { FlowbiteClass } from '../../common';
+export interface DropdownDividerProperties {
+    customStyle: Partial<DropdownDividerTheme>;
+}
+export interface DropdownDividerTheme {
+    root: {
+        base: string;
+    };
+}
+export declare const dropdownDividerTheme: DropdownDividerTheme;
+export type DropdownDividerClass = FlowbiteClass;

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { DropdownDividerClass, DropdownDividerProperties, DropdownDividerTheme } from './dropdown-divider.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DROPDOWN_DIVIDER_THEME_TOKEN: InjectionToken<DropdownDividerTheme>;
+export declare class DropdownDividerThemeService implements FlowbiteThemeService<DropdownDividerProperties> {
+    private readonly baseTheme;
+    getClasses(properties: DropdownDividerProperties): DropdownDividerClass;
+}

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

@@ -0,0 +1,13 @@
+import { BaseComponent } from '../base-component.directive';
+import type { DropdownHeaderClass, DropdownHeaderTheme } from './dropdown-header.theme';
+import { DropdownHeaderThemeService } from './dropdown-header.theme.service';
+import { DropdownComponent } from './dropdown.component';
+import * as i0 from "@angular/core";
+export declare class DropdownHeaderComponent extends BaseComponent<DropdownHeaderClass> {
+    readonly themeService: DropdownHeaderThemeService;
+    readonly dropdownComponent: DropdownComponent;
+    customStyle: import("@angular/core").ModelSignal<Partial<DropdownHeaderTheme>>;
+    fetchClass(): DropdownHeaderClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownHeaderComponent, "flowbite-dropdown-header", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "customStyle": "customStyleChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,16 @@
+import type { DeepPartial, FlowbiteClass } from '../../common';
+export interface DropdownHeaderProperties {
+    customStyle: DeepPartial<DropdownHeaderTheme>;
+}
+export interface DropdownHeaderTheme {
+    root: {
+        base: string;
+    };
+    content: {
+        base: string;
+    };
+}
+export declare const dropdownHeaderTheme: DropdownHeaderTheme;
+export interface DropdownHeaderClass extends FlowbiteClass {
+    root: string;
+}

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { DropdownHeaderClass, DropdownHeaderProperties, DropdownHeaderTheme } from './dropdown-header.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_DROPDOWN_HEADER_THEME_TOKEN: InjectionToken<DropdownHeaderTheme>;
+export declare class DropdownHeaderThemeService implements FlowbiteThemeService<DropdownHeaderProperties> {
+    private readonly baseTheme;
+    getClasses(properties: DropdownHeaderProperties): DropdownHeaderClass;
+}

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

@@ -0,0 +1,17 @@
+import { BaseComponent } from '../base-component.directive';
+import type { DropdownItemClass } from './dropdown-item.theme';
+import { DropdownItemThemeService } from './dropdown-item.theme.service';
+import { DropdownComponent } from './dropdown.component';
+import * as i0 from "@angular/core";
+export declare class DropdownItemComponent extends BaseComponent<DropdownItemClass> {
+    readonly themeService: DropdownItemThemeService;
+    readonly dropdownComponent: DropdownComponent;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): DropdownItemClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownItemComponent, "flowbite-dropdown-item", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "customStyle": "customStyleChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,11 @@
+import type { DeepPartial, FlowbiteClass } from '../../common';
+export interface DropdownItemProperties {
+    customStyle: DeepPartial<DropdownItemTheme>;
+}
+export interface DropdownItemTheme {
+    root: {
+        base: string;
+    };
+}
+export declare const dropdownItemTheme: DropdownItemTheme;
+export type DropdownItemClass = FlowbiteClass;