flowbite-angular 1.0.0-alpha.3 → 1.0.0-alpha.5

package/button/button.theme.d.ts

@@ -1,22 +1,43 @@
 import type { Combination, DeepPartial, FlowbiteBoolean, FlowbiteClass, FlowbiteColors, FlowbiteGradientColors, FlowbiteGradientDuoToneColors, FlowbiteSizes } from 'flowbite-angular';
+/**
+ * Available colors for `ButtonComponent`
+ */
 export interface ButtonColors extends Pick<FlowbiteColors, 'dark' | 'primary' | 'light' | 'blue' | 'red' | 'green' | 'yellow' | 'purple'> {
     [key: string]: string;
 }
+/**
+ * Available monochrome colors for `ButtonComponent`
+ */
 export interface ButtonMonochromeColors extends Pick<FlowbiteGradientColors, 'blue' | 'green' | 'cyan' | 'teal' | 'lime' | 'red' | 'pink' | 'purple'> {
     [key: string]: string;
 }
+/**
+ * Available duotone colors for `ButtonComponent`
+ */
 export type ButtonDuoToneColors = Pick<FlowbiteGradientDuoToneColors, 'purpleToBlue' | 'cyanToBlue' | 'greenToBlue' | 'purpleToPink' | 'pinkToOrange' | 'tealToLime' | 'redToYellow'>;
+/**
+ * Available sizes for `ButtonComponent`
+ */
 export interface ButtonSizes extends Pick<FlowbiteSizes, 'xs' | 'sm' | 'md' | 'lg' | 'xl'> {
     [key: string]: string;
 }
+/**
+ * Available fill for `ButtonComponent`
+ */
 export interface ButtonFill {
     solid: string;
     outline: string;
 }
+/**
+ * Available types for `ButtonComponent`
+ */
 export interface ButtonTypes {
     default: string;
     span: string;
 }
+/**
+ * Required properties for the class generation of `ButtonComponent`
+ */
 export interface ButtonProperties {
     color: keyof ButtonColors;
     gradientMonochrome?: keyof ButtonMonochromeColors;
@@ -27,6 +48,9 @@ export interface ButtonProperties {
     isDisabled: keyof FlowbiteBoolean;
     customStyle: DeepPartial<ButtonTheme>;
 }
+/**
+ * Theme definition for `ButtonComponent`
+ */
 export interface ButtonTheme {
     root: {
         base: ButtonTypes;
@@ -43,7 +67,13 @@ export interface ButtonTheme {
         size: ButtonSizes;
     };
 }
+/**
+ * Default theme for `ButtonComponent`
+ */
 export declare const buttonTheme: ButtonTheme;
+/**
+ * Generated class definition for `ButtonComponent`
+ */
 export interface ButtonClass extends FlowbiteClass {
     spanClass: string;
 }

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

@@ -1,8 +1,19 @@
 import type { ButtonClass, ButtonProperties, ButtonTheme } from './button.theme';
 import type { FlowbiteThemeService } from 'flowbite-angular';
 import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * `InjectionToken` used to import `ButtonTheme` value
+ *
+ * @example
+ * ```
+ * var theme = inject(FLOWBITE_BUTTON_THEME_TOKEN)
+ * ```
+ */
 export declare const FLOWBITE_BUTTON_THEME_TOKEN: InjectionToken<ButtonTheme>;
 export declare class ButtonThemeService implements FlowbiteThemeService<ButtonProperties> {
     private readonly baseTheme;
     getClasses(properties: ButtonProperties): ButtonClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ButtonThemeService>;
 }

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

@@ -4,10 +4,25 @@ import { BaseComponent } from 'flowbite-angular';
 import { IconRegistry } from 'flowbite-angular/icon';
 import { DomSanitizer } from '@angular/platform-browser';
 import * as i0 from "@angular/core";
+/**
+ * Use to toggle light/dark mode accross the site
+ */
 export declare class DarkThemeToggleComponent extends BaseComponent<DarkThemeToggleClass> {
+    /**
+     * Service injected used to generate class
+     */
     readonly themeService: DarkThemeToggleThemeService;
+    /**
+     * `IconRegistry` service
+     */
     readonly iconRegistry: IconRegistry;
+    /**
+     * `DomSanitizer` service
+     */
     readonly domSanitizer: DomSanitizer;
+    /**
+     * Set the custom style for this dark-theme-toggle
+     */
     customStyle: import("@angular/core").ModelSignal<{
         root?: {
             base?: string | undefined;
@@ -15,9 +30,26 @@ export declare class DarkThemeToggleComponent extends BaseComponent<DarkThemeTog
     }>;
     fetchClass(): DarkThemeToggleClass;
     init(): void;
+    /**
+     * Toggle between dark and light mode
+     */
     onClick(): void;
+    /**
+     * Get theme from the `localStorage`
+     * @returns The current theme saved in the `localStorage` with the key `color-theme`
+     */
     private getTheme;
+    /**
+     * Toggle the theme saced in the `localStorage`
+     *
+     * @param theme If provided, force the theme instead of toggling it between light and dark mode
+     */
     private toggleTheme;
+    /**
+     * Set the theme inside the page
+     *
+     * @param theme Theme to apply
+     */
     private setTheme;
     static ɵfac: i0.ɵɵFactoryDeclaration<DarkThemeToggleComponent, 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/dark-theme-toggle/dark-theme-toggle.theme.d.ts

@@ -1,11 +1,23 @@
 import type { DeepPartial, FlowbiteClass } from 'flowbite-angular';
+/**
+ * Required properties for the class generation of `DarkThemeToggleComponent`
+ */
 export interface DarkThemeToggleProperties {
     customStyle: DeepPartial<DarkThemeToggleTheme>;
 }
+/**
+ * Theme definition for `DarkThemeToggleComponent`
+ */
 export interface DarkThemeToggleTheme {
     root: {
         base: string;
     };
 }
+/**
+ * Default theme for `DarkThemeToggleComponent`
+ */
 export declare const darkThemeToggleTheme: DarkThemeToggleTheme;
+/**
+ * Generated class definition for `DarkThemeToggleComponent`
+ */
 export type DarkThemeToggleClass = FlowbiteClass;

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

@@ -1,8 +1,19 @@
 import type { DarkThemeToggleClass, DarkThemeToggleProperties, DarkThemeToggleTheme } from './dark-theme-toggle.theme';
 import type { FlowbiteThemeService } from 'flowbite-angular';
 import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * `InjectionToken` used to import `DarkThemeToggleTheme` value
+ *
+ * @example
+ * ```
+ * var theme = inject(FLOWBITE_DARK_THEME_TOGGLE_THEME_TOKEN)
+ * ```
+ */
 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DarkThemeToggleThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DarkThemeToggleThemeService>;
 }

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

@@ -3,9 +3,21 @@ import { DropdownDividerThemeService } from './dropdown-divider.theme.service';
 import { DropdownComponent } from './dropdown.component';
 import { BaseComponent } from 'flowbite-angular';
 import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/dropdowns/
+ */
 export declare class DropdownDividerComponent extends BaseComponent<DropdownDividerClass> {
+    /**
+     * Service injected used to generate class
+     */
     readonly themeService: DropdownDividerThemeService;
+    /**
+     * The parent `DropdownComponent`
+     */
     readonly dropdownComponent: DropdownComponent;
+    /**
+     * Set the custom style for this dropdown divider
+     */
     customStyle: import("@angular/core").ModelSignal<Partial<DropdownDividerTheme>>;
     fetchClass(): DropdownDividerClass;
     static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDividerComponent, never>;

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

@@ -1,11 +1,23 @@
 import type { FlowbiteClass } from 'flowbite-angular';
+/**
+ * Required properties for the class generation of `DropdownDividerComponent`
+ */
 export interface DropdownDividerProperties {
     customStyle: Partial<DropdownDividerTheme>;
 }
+/**
+ * Theme definition for `DropdownDividerComponent`
+ */
 export interface DropdownDividerTheme {
     root: {
         base: string;
     };
 }
+/**
+ * Default theme for `DropdownDividerComponent`
+ */
 export declare const dropdownDividerTheme: DropdownDividerTheme;
+/**
+ * Generated class definition for `DropdownDividerComponent`
+ */
 export type DropdownDividerClass = FlowbiteClass;

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

@@ -1,8 +1,19 @@
 import type { DropdownDividerClass, DropdownDividerProperties, DropdownDividerTheme } from './dropdown-divider.theme';
 import type { FlowbiteThemeService } from 'flowbite-angular';
 import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * `InjectionToken` used to import `DropdownDividerTheme` value
+ *
+ * @example
+ * ```
+ * var theme = inject(FLOWBITE_DROPDOWN_DIVIDER_THEME_TOKEN)
+ * ```
+ */
 export declare const FLOWBITE_DROPDOWN_DIVIDER_THEME_TOKEN: InjectionToken<DropdownDividerTheme>;
 export declare class DropdownDividerThemeService implements FlowbiteThemeService<DropdownDividerProperties> {
     private readonly baseTheme;
     getClasses(properties: DropdownDividerProperties): DropdownDividerClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownDividerThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownDividerThemeService>;
 }

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

@@ -3,9 +3,21 @@ import { DropdownHeaderThemeService } from './dropdown-header.theme.service';
 import { DropdownComponent } from './dropdown.component';
 import { BaseComponent } from 'flowbite-angular';
 import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/dropdowns/
+ */
 export declare class DropdownHeaderComponent extends BaseComponent<DropdownHeaderClass> {
+    /**
+     * Service injected used to generate class
+     */
     readonly themeService: DropdownHeaderThemeService;
+    /**
+     * The parent `DropdownComponent`
+     */
     readonly dropdownComponent: DropdownComponent;
+    /**
+     * Set the custom style for this dropdown header
+     */
     customStyle: import("@angular/core").ModelSignal<Partial<DropdownHeaderTheme>>;
     fetchClass(): DropdownHeaderClass;
     static ɵfac: i0.ɵɵFactoryDeclaration<DropdownHeaderComponent, never>;

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

@@ -1,7 +1,13 @@
 import type { DeepPartial, FlowbiteClass } from 'flowbite-angular';
+/**
+ * Required properties for the class generation of `DropdownHeaderComponent`
+ */
 export interface DropdownHeaderProperties {
     customStyle: DeepPartial<DropdownHeaderTheme>;
 }
+/**
+ * Theme definition of `DropdownHeaderComponent`
+ */
 export interface DropdownHeaderTheme {
     root: {
         base: string;
@@ -10,7 +16,13 @@ export interface DropdownHeaderTheme {
         base: string;
     };
 }
+/**
+ * Default theme for `DropdownHeaderComponent`
+ */
 export declare const dropdownHeaderTheme: DropdownHeaderTheme;
+/**
+ * Generated class definition for `DropdownHeaderComponent`
+ */
 export interface DropdownHeaderClass extends FlowbiteClass {
     root: string;
 }

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

@@ -1,8 +1,19 @@
 import type { DropdownHeaderClass, DropdownHeaderProperties, DropdownHeaderTheme } from './dropdown-header.theme';
 import type { FlowbiteThemeService } from 'flowbite-angular';
 import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * `InjectionToken` used to import `DropdownHeaderTheme` value
+ *
+ * @example
+ * ```
+ * var theme = inject(FLOWBITE_DROPDOWN_HEADER_THEME_TOKEN)
+ * ```
+ */
 export declare const FLOWBITE_DROPDOWN_HEADER_THEME_TOKEN: InjectionToken<DropdownHeaderTheme>;
 export declare class DropdownHeaderThemeService implements FlowbiteThemeService<DropdownHeaderProperties> {
     private readonly baseTheme;
     getClasses(properties: DropdownHeaderProperties): DropdownHeaderClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownHeaderThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownHeaderThemeService>;
 }

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

@@ -3,9 +3,21 @@ import { DropdownItemThemeService } from './dropdown-item.theme.service';
 import { DropdownComponent } from './dropdown.component';
 import { BaseComponent } from 'flowbite-angular';
 import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/dropdowns/
+ */
 export declare class DropdownItemComponent extends BaseComponent<DropdownItemClass> {
+    /**
+     * Service injected used to generate class
+     */
     readonly themeService: DropdownItemThemeService;
+    /**
+     * The parent `DropdownComponent`
+     */
     readonly dropdownComponent: DropdownComponent;
+    /**
+     * Set the custom style for this dropdown item
+     */
     customStyle: import("@angular/core").ModelSignal<{
         root?: {
             base?: string | undefined;

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

@@ -1,11 +1,23 @@
 import type { DeepPartial, FlowbiteClass } from 'flowbite-angular';
+/**
+ * Required properties for the cmass generation of `DropdownItemComponent`
+ */
 export interface DropdownItemProperties {
     customStyle: DeepPartial<DropdownItemTheme>;
 }
+/**
+ * Theme definition for `DropdownItemComponent`
+ */
 export interface DropdownItemTheme {
     root: {
         base: string;
     };
 }
+/**
+ * Default theme value for `DropdownItemComponent`
+ */
 export declare const dropdownItemTheme: DropdownItemTheme;
+/**
+ * Generated class definition for `DropdownItemComponent`
+ */
 export type DropdownItemClass = FlowbiteClass;

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

@@ -1,8 +1,19 @@
 import type { DropdownItemClass, DropdownItemProperties, DropdownItemTheme } from './dropdown-item.theme';
 import type { FlowbiteThemeService } from 'flowbite-angular';
 import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * `InjectionToken` used to import `DropdownItemTheme` value
+ *
+ * @example
+ * ```
+ * var theme = inject(FLOWBITE_DROPDOWN_ITEM_THEME_TOKEN)
+ * ```
+ */
 export declare const FLOWBITE_DROPDOWN_ITEM_THEME_TOKEN: InjectionToken<DropdownItemTheme>;
 export declare class DropdownItemThemeService implements FlowbiteThemeService<DropdownItemProperties> {
     private readonly baseTheme;
     getClasses(properties: DropdownItemProperties): DropdownItemClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownItemThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownItemThemeService>;
 }

package/dropdown/dropdown.component.d.ts

@@ -16,15 +16,51 @@ import * as i0 from "@angular/core";
 export declare class DropdownComponent extends BaseComponent<DropdownClass> implements AfterViewInit {
     dropdown: ElementRef;
     button: ElementRef;
+    /**
+     * Service injected used to generate class
+     */
     readonly themeService: DropdownThemeService;
+    /**
+     * `IconRegistry` service
+     */
     readonly iconRegistry: IconRegistry;
+    /**
+     * `DomSanitizer` service
+     */
     readonly domSanitizer: DomSanitizer;
+    /**
+     * List of `DropdownItemComponent`
+     */
     readonly dropdownItemChildren: import("@angular/core").Signal<readonly DropdownItemComponent[]>;
+    /**
+     * List of `DropdownHeaderComponent`
+     */
     readonly dropdownHeaderChildren: import("@angular/core").Signal<readonly DropdownHeaderComponent[]>;
+    /**
+     * List of `DropdownDividerComponent`
+     */
     readonly dropdownDividerChildren: import("@angular/core").Signal<readonly DropdownDividerComponent[]>;
+    /**
+     * Set the dropdown label
+     *
+     * @default Dropdown
+     */
     label: import("@angular/core").ModelSignal<string>;
+    /**
+     * Set if the dropdown is open
+     *
+     * @default false
+     */
     isOpen: import("@angular/core").ModelSignal<boolean>;
+    /**
+     * Set the dropdown position
+     *
+     * @default bottom-center
+     */
     position: import("@angular/core").ModelSignal<keyof DropdownPositions>;
+    /**
+     * Set the custom style for this dropdown
+     */
     customStyle: import("@angular/core").ModelSignal<{
         root?: {
             base?: string | undefined;
@@ -61,6 +97,9 @@ export declare class DropdownComponent extends BaseComponent<DropdownClass> impl
     x: number;
     y: number;
     width: number;
+    /**
+     * Toggle dropdown isOpen
+     */
     toggle(): void;
     calculatePosition(): void;
     ngAfterViewInit(): void;

package/dropdown/dropdown.theme.d.ts

@@ -1,14 +1,23 @@
 import type { DeepPartial, FlowbiteBoolean, FlowbiteClass, FlowbitePositions } from 'flowbite-angular';
+/**
+ * Available positions for `DropdownComponent`
+ */
 export interface DropdownPositions extends Pick<FlowbitePositions, 'bottom-center' | 'top-center'> {
     'left-center': string;
     'right-center': string;
 }
+/**
+ * Required properties for the class generation of `DropdownComponent`
+ */
 export interface DropdownProperties {
     label: string;
     isOpen: keyof FlowbiteBoolean;
     placement: keyof DropdownPositions;
     customStyle: DeepPartial<DropdownTheme>;
 }
+/**
+ * Theme definition for `DropdownComponent`
+ */
 export interface DropdownTheme {
     root: {
         base: string;
@@ -31,7 +40,13 @@ export interface DropdownTheme {
         base: string;
     };
 }
+/**
+ * Default theme for `DropdownComponent`
+ */
 export declare const dropdownTheme: DropdownTheme;
+/**
+ * Generated class definition for `DropdownComponent`
+ */
 export interface DropdownClass extends FlowbiteClass {
     dropdownClass: string;
     spanClass: string;

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

@@ -1,8 +1,19 @@
 import type { DropdownClass, DropdownProperties, DropdownTheme } from './dropdown.theme';
 import type { FlowbiteThemeService } from 'flowbite-angular';
 import { InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * `InjectionToken` used to import `DropdownTheme` value
+ *
+ * @example
+ * ```
+ * var theme = inject(FLOWBITE_DROPDOWN_THEME_TOKEN)
+ * ```
+ */
 export declare const FLOWBITE_DROPDOWN_THEME_TOKEN: InjectionToken<DropdownTheme>;
 export declare class DropdownThemeService implements FlowbiteThemeService<DropdownProperties> {
     private readonly baseTheme;
     getClasses(properties: DropdownProperties): DropdownClass;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DropdownThemeService>;
 }

package/esm2022/accordion/accordion-content.component.mjs

@@ -4,13 +4,30 @@ import { BaseComponent, booleanToFlowbiteBoolean } from 'flowbite-angular';
 import { NgClass, NgIf } from '@angular/common';
 import { ChangeDetectionStrategy, Component, inject, model, ViewEncapsulation, } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * @see https://flowbite.com/docs/components/accordion/
+ */
 export class AccordionContentComponent extends BaseComponent {
     constructor() {
         super(...arguments);
+        /**
+         * Service injected used to generate class
+         */
         this.themeService = inject(AccordionContentThemeService);
+        /**
+         * The parent `AccordionPanelComponent`
+         */
         this.accordionPanelComponent = inject(AccordionPanelComponent);
         //#region properties
+        /**
+         * Set the accordion content color
+         *
+         @default `AccordionPanelComponent`'s color
+         */
         this.color = model(this.accordionPanelComponent.color());
+        /**
+         * Set the custom style for this accordion content
+         */
         this.customStyle = model({});
     }
     //#endregion
@@ -44,4 +61,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImpor
                     changeDetection: ChangeDetectionStrategy.OnPush,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/accordion/accordion-content.theme.mjs

@@ -1,4 +1,7 @@
 import { createTheme } from 'flowbite-angular/utils';
+/**
+ * Default theme for `AccordionContentComponent`
+ */
 export const accordionContentTheme = createTheme({
     root: {
         base: 'flex flex-col gap-2',
@@ -16,4 +19,4 @@ export const accordionContentTheme = createTheme({
         },
     },
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/accordion/accordion-content.theme.service.mjs

@@ -1,6 +1,15 @@
 import { mergeTheme } from 'flowbite-angular/utils';
-import { inject, InjectionToken } from '@angular/core';
+import { inject, Injectable, InjectionToken } from '@angular/core';
 import { twMerge } from 'tailwind-merge';
+import * as i0 from "@angular/core";
+/**
+ * `InjectionToken` used to import `AccordionContentTheme` value
+ *
+ * @example
+ * ```
+ * var theme = inject(FLOWBITE_ACCORDION_CONTENT_THEME_TOKEN)
+ * ```
+ */
 export const FLOWBITE_ACCORDION_CONTENT_THEME_TOKEN = new InjectionToken('FLOWBITE_ACCORDION_CONTENT_THEME_TOKEN');
 export class AccordionContentThemeService {
     constructor() {
@@ -13,5 +22,13 @@ export class AccordionContentThemeService {
         };
         return output;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AccordionContentThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AccordionContentThemeService, providedIn: 'root' }); }
 }
-//# sourceMappingURL=data:application/json;base64,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
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AccordionContentThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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