flowbite-angular 0.0.2 → 1.0.0-alpha.1

package/lib/components/icon/icon-registry.d.ts

@@ -0,0 +1,45 @@
+import type { TrustedHTML } from './trusted-types';
+import type { OnDestroy } from '@angular/core';
+import type { SafeHtml } from '@angular/platform-browser';
+import { type SafeResourceUrl } from '@angular/platform-browser';
+import { type Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare function getSvgIconFromNamedError(iconName: string): Error;
+export declare function getSvgIconFailedToSanitizeRawError(raw: SafeHtml): Error;
+export declare function getSvgIconFailedToSanitizeUrlError(url: SafeResourceUrl): Error;
+export declare function getSvgIconNoHttpClientProvidedError(): Error;
+export interface SvgIconOptions {
+    viewBox: string;
+}
+export declare class SvgIconConfig {
+    url: SafeResourceUrl;
+    svgText: TrustedHTML | undefined;
+    options?: SvgIconOptions | undefined;
+    svgElement: SVGElement | null;
+    constructor(url: SafeResourceUrl, svgText: TrustedHTML | undefined, options?: SvgIconOptions | undefined);
+}
+export declare class IconRegistry implements OnDestroy {
+    private platformId;
+    private _httpClient;
+    private _sanitizer;
+    private _document;
+    private _svgIconConfig;
+    private _cachedSvgIconByUrl;
+    private _inProgressSvgIconFetch;
+    addSvgIcon(iconName: string, url: SafeResourceUrl, options?: SvgIconOptions): this;
+    addRawSvgIcon(iconName: string, raw: SafeHtml, options?: SvgIconOptions): this;
+    addSvgIconInNamespace(namespace: string, iconName: string, url: SafeResourceUrl, options?: SvgIconOptions): this;
+    addRawSvgIconInNamepsace(namespace: string, iconName: string, raw: SafeHtml, options?: SvgIconOptions): this;
+    getSvgIconFromUrl(safeUrl: SafeResourceUrl): Observable<SVGElement>;
+    getSvgIconFromName(iconName: string, namespace: string): Observable<SVGElement>;
+    ngOnDestroy(): void;
+    private _addSvgIconConfig;
+    private _getSvgIconFromConfig;
+    private _loadSvgIconFromConfig;
+    private _setSvgAttributes;
+    private _svgElementFromConfig;
+    private _svgElementFromString;
+    private _fetchIcon;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconRegistry, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconRegistry>;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Thanks to Angular Material for Icon part of this library : https://github.com/angular/components
+ */
+import type { FlowbiteClass } from '../../common';
+import { BaseComponent } from '../base-component.directive';
+import { IconRegistry } from './icon-registry';
+import type { OnInit } from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class IconComponent extends BaseComponent<FlowbiteClass> implements OnInit {
+    _elementRef: ElementRef<HTMLElement>;
+    _iconRegistry: IconRegistry;
+    svgIcon: import("@angular/core").ModelSignal<string>;
+    init(): void;
+    fetchClass(): FlowbiteClass;
+    private _splitIconName;
+    private _updateSvgIcon;
+    private _setSvgElement;
+    private _clearSvgElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "flowbite-icon", never, { "svgIcon": { "alias": "svgIcon"; "required": true; "isSignal": true; }; }, { "svgIcon": "svgIconChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,5 @@
+export { IconComponent } from './icon.component';
+export type { SvgIconOptions } from './icon-registry';
+export { IconRegistry, SvgIconConfig, getSvgIconFailedToSanitizeRawError, getSvgIconFailedToSanitizeUrlError, getSvgIconFromNamedError, getSvgIconNoHttpClientProvidedError, } from './icon-registry';
+export type { TrustedHTML, TrustedTypePolicy, TrustedTypePolicyFactory } from './trusted-types';
+export { trustedHTMLFromString } from './trusted-types';

package/lib/components/icon/trusted-types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Thanks to Angular Material for Icon part of this library : https://github.com/angular/components
+ */
+export declare interface TrustedHTML {
+    __brand__: 'TrustedHTML';
+}
+export declare interface TrustedTypePolicyFactory {
+    createPolicy(policyName: string, policyOptions: {
+        createHTML?: (input: string) => string;
+    }): TrustedTypePolicy;
+}
+export declare interface TrustedTypePolicy {
+    createHTML(input: string): TrustedHTML;
+}
+export declare function trustedHTMLFromString(raw: string): TrustedHTML;

package/lib/components/index.d.ts

@@ -1,5 +1,15 @@
+export * from './accordion';
 export * from './alert';
 export * from './badge';
+export * from './breadcrumb';
+export * from './button';
 export * from './dark-theme-toggle';
+export * from './dropdown';
+export * from './form-field';
+export * from './icon';
+export * from './indicators';
+export * from './modal';
 export * from './navbar';
+export * from './scroll-top';
 export * from './sidebar';
+export { BaseComponent } from './base-component.directive';

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

@@ -0,0 +1,4 @@
+export { IndicatorComponent } from './indicators.component';
+export type { IndicatorProperties, indicatorClass, IndicatorColors, IndicatorTheme, IndicatorPositions, IndicatorSizes, } from './indicators.theme';
+export { indicatorTheme } from './indicators.theme';
+export { FLOWBITE_INDICATOR_THEME_TOKEN, IndicatorThemeService } from './indicators.theme.service';

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

@@ -0,0 +1,92 @@
+import { BaseComponent } from '../base-component.directive';
+import type { indicatorClass, IndicatorColors, IndicatorPositions, IndicatorSizes } from './indicators.theme';
+import { IndicatorThemeService } from './indicators.theme.service';
+import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/indicators/
+ */
+export declare class IndicatorComponent extends BaseComponent<indicatorClass> {
+    readonly themeService: IndicatorThemeService;
+    isPill: import("@angular/core").ModelSignal<boolean>;
+    isOutline: import("@angular/core").ModelSignal<boolean>;
+    isDisabled: import("@angular/core").ModelSignal<boolean>;
+    hasOffset: import("@angular/core").ModelSignal<boolean>;
+    isRounded: import("@angular/core").ModelSignal<boolean>;
+    hasBorder: import("@angular/core").ModelSignal<boolean>;
+    color: import("@angular/core").ModelSignal<keyof IndicatorColors>;
+    size: import("@angular/core").ModelSignal<keyof IndicatorSizes>;
+    placement: import("@angular/core").ModelSignal<keyof IndicatorPositions | undefined>;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+            isPill?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            isOutline?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            isDisabled?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            hasOffset?: {
+                [x: string]: string | undefined;
+                'bottom-center'?: string | undefined;
+                'top-center'?: string | undefined;
+                'bottom-left'?: string | undefined;
+                'bottom-right'?: string | undefined;
+                'top-left'?: string | undefined;
+                'top-right'?: string | undefined;
+                'center-left'?: string | undefined;
+                center?: string | undefined;
+                'center-right'?: string | undefined;
+            } | undefined;
+            isRounded?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            hasBorder?: {
+                enabled?: string | undefined;
+                disabled?: string | undefined;
+            } | undefined;
+            color?: {
+                [x: string]: string | undefined;
+                primary?: string | undefined;
+                blue?: string | undefined;
+                red?: string | undefined;
+                green?: string | undefined;
+                yellow?: string | undefined;
+                dark?: string | undefined;
+                gray?: string | undefined;
+                indigo?: string | undefined;
+                purple?: string | undefined;
+                teal?: string | undefined;
+            } | undefined;
+            size?: {
+                [x: string]: string | undefined;
+                xs?: string | undefined;
+                sm?: string | undefined;
+                md?: string | undefined;
+                lg?: string | undefined;
+                xl?: string | undefined;
+            } | undefined;
+            placement?: {
+                [x: string]: string | undefined;
+                'bottom-center'?: string | undefined;
+                'top-center'?: string | undefined;
+                'bottom-left'?: string | undefined;
+                'bottom-right'?: string | undefined;
+                'top-left'?: string | undefined;
+                'top-right'?: string | undefined;
+                'center-left'?: string | undefined;
+                center?: string | undefined;
+                'center-right'?: string | undefined;
+            } | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): indicatorClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IndicatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IndicatorComponent, "flowbite-indicator", never, { "isPill": { "alias": "isPill"; "required": false; "isSignal": true; }; "isOutline": { "alias": "isOutline"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; "hasOffset": { "alias": "hasOffset"; "required": false; "isSignal": true; }; "isRounded": { "alias": "isRounded"; "required": false; "isSignal": true; }; "hasBorder": { "alias": "hasBorder"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "isPill": "isPillChange"; "isOutline": "isOutlineChange"; "isDisabled": "isDisabledChange"; "hasOffset": "hasOffsetChange"; "isRounded": "isRoundedChange"; "hasBorder": "hasBorderChange"; "color": "colorChange"; "size": "sizeChange"; "placement": "placementChange"; "customStyle": "customStyleChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,43 @@
+import type { DeepPartial } from '../../common';
+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 { FlowbitePositions } from '../../common/type-definitions/flowbite.positions';
+import type { FlowbiteSizes } from '../../common/type-definitions/flowbite.sizes';
+export interface IndicatorColors extends Pick<FlowbiteColors, 'primary' | 'dark' | 'gray' | 'blue' | 'green' | 'red' | 'purple' | 'indigo' | 'yellow' | 'teal'> {
+    [key: string]: string;
+}
+export interface IndicatorSizes extends Pick<FlowbiteSizes, 'xs' | 'sm' | 'md' | 'lg' | 'xl'> {
+    [key: string]: string;
+}
+export interface IndicatorPositions extends Pick<FlowbitePositions, 'top-left' | 'top-center' | 'top-right' | 'center-left' | 'center' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right'> {
+    [key: string]: string;
+}
+export interface IndicatorProperties {
+    isPill: keyof FlowbiteBoolean;
+    isOutline: keyof FlowbiteBoolean;
+    isDisabled: keyof FlowbiteBoolean;
+    hasOffset: keyof FlowbiteBoolean;
+    isRounded: keyof FlowbiteBoolean;
+    hasBorder: keyof FlowbiteBoolean;
+    color: keyof IndicatorColors;
+    size: keyof IndicatorSizes;
+    placement?: keyof IndicatorPositions;
+    customStyle: DeepPartial<IndicatorTheme>;
+}
+export interface IndicatorTheme {
+    root: {
+        base: string;
+        isPill: FlowbiteBoolean;
+        isOutline: FlowbiteBoolean;
+        isDisabled: FlowbiteBoolean;
+        hasOffset: IndicatorPositions;
+        isRounded: FlowbiteBoolean;
+        hasBorder: FlowbiteBoolean;
+        color: IndicatorColors;
+        size: IndicatorSizes;
+        placement: IndicatorPositions;
+    };
+}
+export declare const indicatorTheme: IndicatorTheme;
+export type indicatorClass = FlowbiteClass;

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { indicatorClass, IndicatorProperties, IndicatorTheme } from './indicators.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_INDICATOR_THEME_TOKEN: InjectionToken<IndicatorTheme>;
+export declare class IndicatorThemeService implements FlowbiteThemeService<IndicatorProperties> {
+    private readonly baseTheme;
+    getClasses(properties: IndicatorProperties): indicatorClass;
+}

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

@@ -0,0 +1,16 @@
+export { ModalComponent } from './modal.component';
+export type { ModalProperties, ModalClass, ModalPositions, ModalSizes, ModalTheme } from './modal.theme';
+export { modalTheme } from './modal.theme';
+export { FLOWBITE_MODAL_THEME_TOKEN, ModalThemeService } from './modal.theme.service';
+export { ModalHeaderComponent } from './modal-header.component';
+export type { ModalHeaderProperties, ModalHeaderClass, ModalHeaderTheme } from './modal-header.theme';
+export { modalHeaderTheme } from './modal-header.theme';
+export { FLOWBITE_MODAL_HEADER_THEME_TOKEN, ModalHeaderThemeService } from './modal-header.theme.service';
+export { ModalBodyComponent } from './modal-body.component';
+export type { ModalBodyProperties, ModalBodyClass, ModalBodyTheme } from './modal-body.theme';
+export { modalBodyTheme } from './modal-body.theme';
+export { FLOWBITE_MODAL_BODY_THEME_TOKEN, ModalBodyThemeService } from './modal-body.theme.service';
+export { ModalFooterComponent } from './modal-footer.component';
+export type { ModalFooterProperties, ModalFooterClass, ModalFooterTheme } from './modal-footer.theme';
+export { modalFooterTheme } from './modal-footer.theme';
+export { FLOWBITE_MODAL_FOOTER_THEME_TOKEN, ModalFooterThemeService } from './modal-footer.theme.service';

package/lib/components/modal/modal-body.component.d.ts

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

package/lib/components/modal/modal-body.theme.d.ts

@@ -0,0 +1,11 @@
+import type { DeepPartial, FlowbiteClass } from '../../common';
+export interface ModalBodyProperties {
+    customStyle: DeepPartial<ModalBodyTheme>;
+}
+export interface ModalBodyTheme {
+    root: {
+        base: string;
+    };
+}
+export declare const modalBodyTheme: ModalBodyTheme;
+export type ModalBodyClass = FlowbiteClass;

package/lib/components/modal/modal-body.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { ModalBodyClass, ModalBodyProperties, ModalBodyTheme } from './modal-body.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_MODAL_BODY_THEME_TOKEN: InjectionToken<ModalBodyTheme>;
+export declare class ModalBodyThemeService implements FlowbiteThemeService<ModalBodyProperties> {
+    private readonly baseTheme;
+    getClasses(properties: ModalBodyProperties): ModalBodyClass;
+}

package/lib/components/modal/modal-footer.component.d.ts

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

package/lib/components/modal/modal-footer.theme.d.ts

@@ -0,0 +1,11 @@
+import type { DeepPartial, FlowbiteClass } from '../../common';
+export interface ModalFooterProperties {
+    customStyle: DeepPartial<ModalFooterTheme>;
+}
+export interface ModalFooterTheme {
+    root: {
+        base: string;
+    };
+}
+export declare const modalFooterTheme: ModalFooterTheme;
+export type ModalFooterClass = FlowbiteClass;

package/lib/components/modal/modal-footer.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { ModalFooterClass, ModalFooterProperties, ModalFooterTheme } from './modal-footer.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_MODAL_FOOTER_THEME_TOKEN: InjectionToken<ModalFooterTheme>;
+export declare class ModalFooterThemeService implements FlowbiteThemeService<ModalFooterProperties> {
+    private readonly baseTheme;
+    getClasses(properties: ModalFooterProperties): ModalFooterClass;
+}

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

@@ -0,0 +1,29 @@
+import { BaseComponent } from '../base-component.directive';
+import { IconRegistry } from '../icon';
+import type { ModalHeaderClass } from './modal-header.theme';
+import { ModalHeaderThemeService } from './modal-header.theme.service';
+import { ModalComponent } from './modal.component';
+import type { OnInit } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class ModalHeaderComponent extends BaseComponent<ModalHeaderClass> implements OnInit {
+    readonly stateService: ModalHeaderThemeService;
+    readonly modalComponent: ModalComponent;
+    readonly iconRegistry: IconRegistry;
+    readonly domSanitizer: DomSanitizer;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+        } | undefined;
+        title?: {
+            base?: string | undefined;
+        } | undefined;
+        button?: {
+            base?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): ModalHeaderClass;
+    init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalHeaderComponent, "flowbite-modal-header", never, { "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "customStyle": "customStyleChange"; }, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,20 @@
+import type { DeepPartial, FlowbiteClass } from '../../common';
+export interface ModalHeaderProperties {
+    customStyle: DeepPartial<ModalHeaderTheme>;
+}
+export interface ModalHeaderTheme {
+    root: {
+        base: string;
+    };
+    title: {
+        base: string;
+    };
+    button: {
+        base: string;
+    };
+}
+export declare const modalHeaderTheme: ModalHeaderTheme;
+export interface ModalHeaderClass extends FlowbiteClass {
+    modalHeaderTitleClass: string;
+    modalHeaderButtonClass: string;
+}

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { ModalHeaderClass, ModalHeaderProperties, ModalHeaderTheme } from './modal-header.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_MODAL_HEADER_THEME_TOKEN: InjectionToken<ModalHeaderTheme>;
+export declare class ModalHeaderThemeService implements FlowbiteThemeService<ModalHeaderProperties> {
+    private readonly baseTheme;
+    getClasses(properties: ModalHeaderProperties): ModalHeaderClass;
+}

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

@@ -0,0 +1,73 @@
+import { BaseComponent } from '../base-component.directive';
+import { ModalBodyComponent } from './modal-body.component';
+import { ModalFooterComponent } from './modal-footer.component';
+import { ModalHeaderComponent } from './modal-header.component';
+import type { ModalClass, ModalPositions, ModalSizes } from './modal.theme';
+import { ModalThemeService } from './modal.theme.service';
+import type { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/modal/
+ */
+export declare class ModalComponent extends BaseComponent<ModalClass> implements OnDestroy {
+    private readonly destroyed;
+    readonly themeService: ModalThemeService;
+    readonly modalHeaderChild: import("@angular/core").Signal<ModalHeaderComponent | undefined>;
+    readonly modalBodyChild: import("@angular/core").Signal<ModalBodyComponent | undefined>;
+    readonly modalFooterChild: import("@angular/core").Signal<ModalFooterComponent | undefined>;
+    private readonly template;
+    private readonly viewContainer;
+    private readonly router;
+    private embeddedView?;
+    size: import("@angular/core").ModelSignal<keyof ModalSizes>;
+    position: import("@angular/core").ModelSignal<keyof ModalPositions>;
+    isDismissable: import("@angular/core").ModelSignal<boolean>;
+    isOpen: import("@angular/core").ModelSignal<boolean>;
+    customStyle: import("@angular/core").ModelSignal<{
+        root?: {
+            base?: string | undefined;
+        } | undefined;
+        wrapper?: {
+            base?: string | undefined;
+            position?: {
+                [x: string]: string | undefined;
+                'bottom-center'?: string | undefined;
+                'top-center'?: string | undefined;
+                'bottom-left'?: string | undefined;
+                'bottom-right'?: string | undefined;
+                'top-left'?: string | undefined;
+                'top-right'?: string | undefined;
+                'center-left'?: string | undefined;
+                center?: string | undefined;
+                'center-right'?: string | undefined;
+            } | undefined;
+        } | undefined;
+        container?: {
+            base?: string | undefined;
+            size?: {
+                [x: string]: string | undefined;
+                sm?: string | undefined;
+                md?: string | undefined;
+                lg?: string | undefined;
+                xl?: string | undefined;
+            } | undefined;
+        } | undefined;
+        content?: {
+            base?: string | undefined;
+        } | undefined;
+    }>;
+    fetchClass(): ModalClass;
+    init(): void;
+    verify(): void;
+    ngOnDestroy(): void;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    changeBackdrop(): void;
+    private createTemplate;
+    private destroyTemplate;
+    onKeydownHandler(event: KeyboardEvent): void;
+    onBackdropClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "flowbite-modal", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "isDismissable": { "alias": "isDismissable"; "required": false; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "customStyle": { "alias": "customStyle"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; "position": "positionChange"; "isDismissable": "isDismissableChange"; "isOpen": "isOpenChange"; "customStyle": "customStyleChange"; }, ["modalHeaderChild", "modalBodyChild", "modalFooterChild"], ["*"], true, never>;
+}

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

@@ -0,0 +1,39 @@
+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';
+import type { FlowbiteSizes } from '../../common/type-definitions/flowbite.sizes';
+export interface ModalSizes extends Pick<FlowbiteSizes, 'sm' | 'md' | 'lg' | 'xl'> {
+    [key: string]: string;
+}
+export interface ModalPositions extends Pick<FlowbitePositions, 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center' | 'center-left' | 'center-right'> {
+    [key: string]: string;
+}
+export interface ModalProperties {
+    isOpen: keyof FlowbiteBoolean;
+    size: keyof ModalSizes;
+    position: keyof ModalPositions;
+    customStyle: DeepPartial<ModalTheme>;
+}
+export interface ModalTheme {
+    root: {
+        base: string;
+    };
+    wrapper: {
+        base: string;
+        position: ModalPositions;
+    };
+    container: {
+        base: string;
+        size: ModalSizes;
+    };
+    content: {
+        base: string;
+    };
+}
+export declare const modalTheme: ModalTheme;
+export interface ModalClass extends FlowbiteClass {
+    modalWrapperClass: string;
+    modalContainerClass: string;
+    modalContentClass: string;
+}

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

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { ModalClass, ModalProperties, ModalTheme } from './modal.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_MODAL_THEME_TOKEN: InjectionToken<ModalTheme>;
+export declare class ModalThemeService implements FlowbiteThemeService<ModalProperties> {
+    private readonly baseTheme;
+    getClasses(properties: ModalProperties): ModalClass;
+}

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

@@ -1 +1,24 @@
-export * from './navbar.component';
+export { NavbarComponent } from './navbar.component';
+export type { NavbarProperties, NavbarClass, NavbarColors, NavbarTheme } from './navbar.theme';
+export { navbarTheme } from './navbar.theme';
+export { FLOWBITE_NAVBAR_THEME_TOKEN, NavbarThemeService } from './navbar.theme.service';
+export { NavbarBrandComponent } from './navbar-brand.component';
+export type { NavbarBrandProperties, NavbarBrandClass, NavbarBrandTheme } from './navbar-brand.theme';
+export { navbarBrandTheme } from './navbar-brand.theme';
+export { FLOWBITE_NAVBAR_BRAND_THEME_TOKEN, NavbarBrandThemeService } from './navbar-brand.theme.service';
+export { NavbarContentComponent } from './navbar-content.component';
+export type { NavbarContentProperties, NavbarContentClass, NavbarContentTheme } from './navbar-content.theme';
+export { navbarContentTheme } from './navbar-content.theme';
+export { FLOWBITE_NAVBAR_CONTENT_THEME_TOKEN, NavbarContentThemeService } from './navbar-content.theme.service';
+export { NavbarItemComponent } from './navbar-item.component';
+export type { NabvarItemProperties, NavbarItemClass, NavbarItemTheme } from './navbar-item.theme';
+export { navbarItemTheme } from './navbar-item.theme';
+export { FLOWBITE_NAVBAR_ITEM_THEME_TOKEN, NavbarItemThemeService } from './navbar-item.theme.service';
+export { NavbarToggleComponent } from './navbar-toggle.component';
+export type { NavbarToggleTheme, NavbarToggleClass, NavbarToggleProperties } from './navbar-toggle.theme';
+export { navbarToogleTheme } from './navbar-toggle.theme';
+export { FLOWBITE_NAVBAR_TOGGLE_THEME_TOKEN, NavbarToggleThemeService } from './navbar-toggle.theme.service';
+export { NavbarIconButtonComponent } from './navbar-icon-button.component';
+export type { NavbarIconButtonProperties, NavbarIconButtonClass, NavbarIconButtonTheme, } from './navbar-icon-button.theme';
+export { navbarIconButtonTheme } from './navbar-icon-button.theme';
+export { FLOWBITE_NAVBAR_ICON_BUTTON_THEME_TOKEN, NavbarIconButtonThemeService, } from './navbar-icon-button.theme.service';

package/lib/components/navbar/navbar-brand.component.d.ts

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

package/lib/components/navbar/navbar-brand.theme.d.ts

@@ -0,0 +1,11 @@
+import type { DeepPartial, FlowbiteClass } from '../../common';
+export interface NavbarBrandProperties {
+    customStyle: DeepPartial<NavbarBrandTheme>;
+}
+export interface NavbarBrandTheme {
+    root: {
+        base: string;
+    };
+}
+export declare const navbarBrandTheme: NavbarBrandTheme;
+export type NavbarBrandClass = FlowbiteClass;

package/lib/components/navbar/navbar-brand.theme.service.d.ts

@@ -0,0 +1,8 @@
+import type { FlowbiteThemeService } from '../../services';
+import type { NavbarBrandClass, NavbarBrandProperties, NavbarBrandTheme } from './navbar-brand.theme';
+import { InjectionToken } from '@angular/core';
+export declare const FLOWBITE_NAVBAR_BRAND_THEME_TOKEN: InjectionToken<NavbarBrandTheme>;
+export declare class NavbarBrandThemeService implements FlowbiteThemeService<NavbarBrandProperties> {
+    private readonly baseTheme;
+    getClasses(properties: NavbarBrandProperties): NavbarBrandClass;
+}