flowbite-angular/accordion/index.d.ts

<div align="center"> <h1>flowbite-angular</h1> <p> Build websites even faster with components on top of Angular and Tailwind CSS </p> <p> <a href="https://discord.com/invite/4eeurUVvTy"> <img src="https://img.shields.io/discord/90291

import * as ng_primitives_state from 'ng-primitives/state';
import * as _angular_core from '@angular/core';
import { InjectionToken, Provider } from '@angular/core';
import * as flowbite_angular_accordion from 'flowbite-angular/accordion';
import { FlowbiteColors, ColorToTheme, DeepPartial, FlowbiteBoolean } from 'flowbite-angular';
import * as i1 from 'ng-primitives/accordion';
import { NgpAccordionItem } from 'ng-primitives/accordion';
import * as i1$1 from 'ng-primitives/button';
import * as i2 from 'ng-primitives/interactions';

interface FlowbiteAccordionColors extends Pick<FlowbiteColors, 'default' | 'info' | 'failure' | 'success' | 'warning' | 'primary'> {
    [key: string]: ColorToTheme;
}
interface FlowbiteAccordionTheme {
    host: FlowbiteAccordionHostTheme;
}
interface FlowbiteAccordionHostTheme {
    base: string;
    transition: string;
}
declare const flowbiteAccordionTheme: FlowbiteAccordionTheme;

interface FlowbiteAccordionConfig {
    /**
     * The default theme of accordion.
     */
    baseTheme: FlowbiteAccordionTheme;
    /**
     * The default color of accordion.
     */
    color: keyof FlowbiteAccordionColors;
    /**
     * Whether the accordion is flush.
     */
    flush: boolean;
    /**
     * The custom theme of button.
     */
    customTheme: DeepPartial<FlowbiteAccordionTheme>;
}
declare const defaultFlowbiteAccordionConfig: FlowbiteAccordionConfig;
declare const FlowbiteAccordionConfigToken: InjectionToken<FlowbiteAccordionConfig>;
/**
 * Provide the default Accordion configuration
 * @param config The Accordion configuration
 * @returns The provider
 */
declare const provideFlowbiteAccordionConfig: (config: Partial<FlowbiteAccordionConfig>) => Provider[];
/**
 * Inject the Accordion configuration
 * @see {@link defaultFlowbiteAccordionConfig}
 * @returns The configuration
 */
declare const injectFlowbiteAccordionConfig: () => FlowbiteAccordionConfig;

declare class Accordion {
    readonly config: FlowbiteAccordionConfig;
    /**
     * @see {@link injectFlowbiteAccordionConfig}
     */
    readonly color: _angular_core.InputSignal<keyof flowbite_angular_accordion.FlowbiteAccordionColors>;
    /**
     * @see {@link injectFlowbiteAccordionConfig}
     */
    readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * @see {@link injectFlowbiteAccordionConfig}
     */
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    /**
     * @internal
     */
    readonly state: ng_primitives_state.CreatedState<Accordion>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Accordion, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Accordion, "    div[flowbiteAccordion]  ", ["flowbiteAccordion"], { "color": { "alias": "color"; "required": false; "isSignal": true; }; "flush": { "alias": "flush"; "required": false; "isSignal": true; }; "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpAccordion; inputs: { "ngpAccordionType": "type"; "ngpAccordionDisabled": "disabled"; "ngpAccordionCollapsible": "collapsible"; }; outputs: {}; }]>;
}

declare const FlowbiteAccordionStateToken: _angular_core.InjectionToken<Accordion>;
declare const provideFlowbiteAccordionState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteAccordionState: <U = {
    readonly config: flowbite_angular_accordion.FlowbiteAccordionConfig;
    readonly color: _angular_core.InputSignal<keyof flowbite_angular_accordion.FlowbiteAccordionColors>;
    readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    readonly state: ng_primitives_state.CreatedState<Accordion>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteAccordionState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteAccordionItemTheme {
    host: FlowbiteAccordionItemHostTheme;
}
interface FlowbiteAccordionItemHostTheme {
    base: string;
    transition: string;
}
declare const flowbiteAccordionItemTheme: FlowbiteAccordionItemTheme;

interface FlowbiteAccordionItemConfig {
    /**
     * The default theme of accordion item.
     */
    baseTheme: FlowbiteAccordionItemTheme;
    /**
     * The custom theme of accordion item.
     */
    customTheme: DeepPartial<FlowbiteAccordionItemTheme>;
}
declare const defaultFlowbiteAccordionItemConfig: FlowbiteAccordionItemConfig;
declare const FlowbiteAccordionItemConfigToken: InjectionToken<FlowbiteAccordionItemConfig>;
/**
 * Provide the default Accordion Item configuration
 * @param config The Accordion Item configuration
 * @returns The provider
 */
declare const provideFlowbiteAccordionItemConfig: (config: Partial<FlowbiteAccordionItemConfig>) => Provider[];
/**
 * Inject the Accordion Item configuration
 * @see {@link defaultFlowbiteAccordionItemConfig}
 * @returns The configuration
 */
declare const injectFlowbiteAccordionItemConfig: () => FlowbiteAccordionItemConfig;

declare class AccordionItem {
    readonly config: FlowbiteAccordionItemConfig;
    readonly accordionState: _angular_core.Signal<ng_primitives_state.State<{
        readonly config: flowbite_angular_accordion.FlowbiteAccordionConfig;
        readonly color: _angular_core.InputSignal<keyof flowbite_angular_accordion.FlowbiteAccordionColors>;
        readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
        readonly customTheme: _angular_core.InputSignal<{
            host?: {
                base?: string | undefined;
                transition?: string | undefined;
            } | undefined;
        }>;
        readonly theme: _angular_core.Signal<{
            host: {
                root: string;
            };
        }>;
        readonly state: ng_primitives_state.CreatedState<flowbite_angular_accordion.Accordion>;
    }>>;
    readonly ngpAccordionItemState: _angular_core.Signal<ng_primitives_state.State<NgpAccordionItem<unknown>>>;
    /**
     * @see {@link injectFlowbiteAccordionItemConfig}
     */
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    /**
     * @internal
     */
    readonly state: ng_primitives_state.CreatedState<AccordionItem>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItem, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionItem, "    div[flowbiteAccordionItem]  ", ["flowbiteAccordionItem"], { "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpAccordionItem; inputs: { "ngpAccordionItemValue": "value"; "ngpAccordionItemDisabled": "disabled"; }; outputs: {}; }]>;
}

declare const FlowbiteAccordionItemStateToken: _angular_core.InjectionToken<AccordionItem>;
declare const provideFlowbiteAccordionItemState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteAccordionItemState: <U = {
    readonly config: flowbite_angular_accordion.FlowbiteAccordionItemConfig;
    readonly accordionState: _angular_core.Signal<ng_primitives_state.State<{
        readonly config: /*elided*/ any;
        readonly color: /*elided*/ any;
        readonly flush: /*elided*/ any;
        readonly customTheme: /*elided*/ any;
        readonly theme: /*elided*/ any;
        readonly state: /*elided*/ any;
    }>>;
    readonly ngpAccordionItemState: _angular_core.Signal<ng_primitives_state.State<i1.NgpAccordionItem<unknown>>>;
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    readonly state: ng_primitives_state.CreatedState<AccordionItem>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteAccordionItemState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteAccordionTitleTheme {
    host: FlowbiteAccordionTitleHostTheme;
}
interface FlowbiteAccordionTitleHostTheme {
    base: string;
    transition: string;
    color: FlowbiteAccordionColors;
    flush: FlowbiteBoolean;
}
declare const flowbiteAccordionTitleTheme: FlowbiteAccordionTitleTheme;

interface FlowbiteAccordionTitleConfig {
    /**
     * The default theme of AccordionTitle
     */
    baseTheme: FlowbiteAccordionTitleTheme;
    /**
     * The custom theme of AccordionTitle
     */
    customTheme: DeepPartial<FlowbiteAccordionTitleTheme>;
}
declare const defaultFlowbiteAccordionTitleConfig: FlowbiteAccordionTitleConfig;
declare const FlowbiteAccordionTitleConfigToken: InjectionToken<FlowbiteAccordionTitleConfig>;
/**
 * Provide the default AccordionTitle configuration
 * @param config The AccordionTitle configuration
 * @returns The provider
 */
declare const provideFlowbiteAccordionTitleConfig: (config: Partial<FlowbiteAccordionTitleConfig>) => Provider[];
/**
 * Inject the AccordionTitle configuration
 * @see {@link defaultFlowbiteAccordionTitleConfig}
 * @returns The configuration
 */
declare const injectFlowbiteAccordionTitleConfig: () => FlowbiteAccordionTitleConfig;

declare class AccordionTitle {
    readonly config: FlowbiteAccordionTitleConfig;
    readonly accordionState: _angular_core.Signal<ng_primitives_state.State<{
        readonly config: flowbite_angular_accordion.FlowbiteAccordionConfig;
        readonly color: _angular_core.InputSignal<keyof flowbite_angular_accordion.FlowbiteAccordionColors>;
        readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
        readonly customTheme: _angular_core.InputSignal<{
            host?: {
                base?: string | undefined;
                transition?: string | undefined;
            } | undefined;
        }>;
        readonly theme: _angular_core.Signal<{
            host: {
                root: string;
            };
        }>;
        readonly state: ng_primitives_state.CreatedState<flowbite_angular_accordion.Accordion>;
    }>>;
    /**
     * @see {@link injectFlowbiteAccordionTitleConfig}
     */
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            color?: {
                [x: string]: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                default?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                info?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                failure?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                success?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                warning?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                primary?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
            } | undefined;
            flush?: {
                off?: string | undefined;
                on?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    /**
     * @internal
     */
    readonly state: ng_primitives_state.CreatedState<AccordionTitle>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTitle, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionTitle, "    [flowbiteAccordionTitle]  ", ["flowbiteAccordionTitle"], { "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1$1.NgpButton; inputs: { "disabled": "disabled"; }; outputs: {}; }, { directive: typeof i2.NgpFocus; inputs: {}; outputs: {}; }, { directive: typeof i1.NgpAccordionTrigger; inputs: { "id": "id"; }; outputs: {}; }]>;
}

declare const FlowbiteAccordionTitleStateToken: _angular_core.InjectionToken<AccordionTitle>;
declare const provideFlowbiteAccordionTitleState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteAccordionTitleState: <U = {
    readonly config: flowbite_angular_accordion.FlowbiteAccordionTitleConfig;
    readonly accordionState: _angular_core.Signal<ng_primitives_state.State<{
        readonly config: /*elided*/ any;
        readonly color: /*elided*/ any;
        readonly flush: /*elided*/ any;
        readonly customTheme: /*elided*/ any;
        readonly theme: /*elided*/ any;
        readonly state: /*elided*/ any;
    }>>;
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            color?: {
                [x: string]: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                default?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                info?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                failure?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                success?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                warning?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                primary?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
            } | undefined;
            flush?: {
                off?: string | undefined;
                on?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    readonly state: ng_primitives_state.CreatedState<AccordionTitle>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteAccordionTitleState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteAccordionContentTheme {
    host: FlowbiteAccordionContentHostTheme;
}
interface FlowbiteAccordionContentHostTheme {
    base: string;
    transition: string;
    color: FlowbiteAccordionColors;
    flush: FlowbiteBoolean;
    open: FlowbiteBoolean;
}
declare const flowbiteAccordionContentTheme: FlowbiteAccordionContentTheme;

interface FlowbiteAccordionContentConfig {
    /**
     * The default theme of AccordionContent
     */
    baseTheme: FlowbiteAccordionContentTheme;
    /**
     * The custom theme of AccordionContent
     */
    customTheme: DeepPartial<FlowbiteAccordionContentTheme>;
}
declare const defaultFlowbiteAccordionContentConfig: FlowbiteAccordionContentConfig;
declare const FlowbiteAccordionContentConfigToken: InjectionToken<FlowbiteAccordionContentConfig>;
/**
 * Provide the default AccordionContent configuration
 * @param config The AccordionContent configuration
 * @returns The provider
 */
declare const provideFlowbiteAccordionContentConfig: (config: Partial<FlowbiteAccordionContentConfig>) => Provider[];
/**
 * Inject the AccordionContent configuration
 * @see {@link defaultFlowbiteAccordionContentConfig}
 * @returns The configuration
 */
declare const injectFlowbiteAccordionContentConfig: () => FlowbiteAccordionContentConfig;

declare class AccordionContent {
    readonly config: FlowbiteAccordionContentConfig;
    readonly accordionState: _angular_core.Signal<ng_primitives_state.State<{
        readonly config: flowbite_angular_accordion.FlowbiteAccordionConfig;
        readonly color: _angular_core.InputSignal<keyof flowbite_angular_accordion.FlowbiteAccordionColors>;
        readonly flush: _angular_core.InputSignalWithTransform<boolean, unknown>;
        readonly customTheme: _angular_core.InputSignal<{
            host?: {
                base?: string | undefined;
                transition?: string | undefined;
            } | undefined;
        }>;
        readonly theme: _angular_core.Signal<{
            host: {
                root: string;
            };
        }>;
        readonly state: ng_primitives_state.CreatedState<flowbite_angular_accordion.Accordion>;
    }>>;
    readonly ngpAccordionItemState: _angular_core.Signal<ng_primitives_state.State<i1.NgpAccordionItem<unknown>>>;
    /**
     * @see {@link injectFlowbiteAccordionContentConfig}
     */
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            color?: {
                [x: string]: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                default?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                info?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                failure?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                success?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                warning?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                primary?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
            } | undefined;
            flush?: {
                off?: string | undefined;
                on?: string | undefined;
            } | undefined;
            open?: {
                off?: string | undefined;
                on?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    /**
     * @internal
     */
    readonly state: ng_primitives_state.CreatedState<AccordionContent>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionContent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionContent, "    div[flowbiteAccordionContent]  ", ["flowbiteAccordionContent"], { "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpAccordionContent; inputs: { "id": "id"; }; outputs: {}; }]>;
}

declare const FlowbiteAccordionContentStateToken: _angular_core.InjectionToken<AccordionContent>;
declare const provideFlowbiteAccordionContentState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteAccordionContentState: <U = {
    readonly config: flowbite_angular_accordion.FlowbiteAccordionContentConfig;
    readonly accordionState: _angular_core.Signal<ng_primitives_state.State<{
        readonly config: /*elided*/ any;
        readonly color: /*elided*/ any;
        readonly flush: /*elided*/ any;
        readonly customTheme: /*elided*/ any;
        readonly theme: /*elided*/ any;
        readonly state: /*elided*/ any;
    }>>;
    readonly ngpAccordionItemState: _angular_core.Signal<ng_primitives_state.State<i1.NgpAccordionItem<unknown>>>;
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            color?: {
                [x: string]: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                default?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                info?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                failure?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                success?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                warning?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
                primary?: {
                    light?: string | undefined;
                    dark?: string | undefined;
                } | undefined;
            } | undefined;
            flush?: {
                off?: string | undefined;
                on?: string | undefined;
            } | undefined;
            open?: {
                off?: string | undefined;
                on?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    readonly state: ng_primitives_state.CreatedState<AccordionContent>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteAccordionContentState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

export { Accordion, AccordionContent, AccordionItem, AccordionTitle, FlowbiteAccordionConfigToken, FlowbiteAccordionContentConfigToken, FlowbiteAccordionContentStateToken, FlowbiteAccordionItemConfigToken, FlowbiteAccordionItemStateToken, FlowbiteAccordionStateToken, FlowbiteAccordionTitleConfigToken, FlowbiteAccordionTitleStateToken, defaultFlowbiteAccordionConfig, defaultFlowbiteAccordionContentConfig, defaultFlowbiteAccordionItemConfig, defaultFlowbiteAccordionTitleConfig, flowbiteAccordionContentState, flowbiteAccordionContentTheme, flowbiteAccordionItemState, flowbiteAccordionItemTheme, flowbiteAccordionState, flowbiteAccordionTheme, flowbiteAccordionTitleState, flowbiteAccordionTitleTheme, injectFlowbiteAccordionConfig, injectFlowbiteAccordionContentConfig, injectFlowbiteAccordionContentState, injectFlowbiteAccordionItemConfig, injectFlowbiteAccordionItemState, injectFlowbiteAccordionState, injectFlowbiteAccordionTitleConfig, injectFlowbiteAccordionTitleState, provideFlowbiteAccordionConfig, provideFlowbiteAccordionContentConfig, provideFlowbiteAccordionContentState, provideFlowbiteAccordionItemConfig, provideFlowbiteAccordionItemState, provideFlowbiteAccordionState, provideFlowbiteAccordionTitleConfig, provideFlowbiteAccordionTitleState };
export type { FlowbiteAccordionColors, FlowbiteAccordionConfig, FlowbiteAccordionContentConfig, FlowbiteAccordionContentHostTheme, FlowbiteAccordionContentTheme, FlowbiteAccordionHostTheme, FlowbiteAccordionItemConfig, FlowbiteAccordionItemHostTheme, FlowbiteAccordionItemTheme, FlowbiteAccordionTheme, FlowbiteAccordionTitleConfig, FlowbiteAccordionTitleHostTheme, FlowbiteAccordionTitleTheme };