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_modal from 'flowbite-angular/modal';
import { FlowbiteSizes, DeepPartial, FlowbitePositions } from 'flowbite-angular';
import * as i1 from 'ng-primitives/dialog';

interface FlowbiteModalSizes extends Pick<FlowbiteSizes, 'sm' | 'md' | 'lg' | 'xl'> {
    [key: string]: string;
}
interface FlowbiteModalTheme {
    host: FlowbiteModalHostTheme;
}
interface FlowbiteModalHostTheme {
    base: string;
    transition: string;
    size: FlowbiteModalSizes;
}
declare const flowbiteModalTheme: FlowbiteModalTheme;

declare class Modal {
    protected readonly config: flowbite_angular_modal.FlowbiteModalConfig;
    /**
     * @see {@link injectFlowbiteModalConfig}
     */
    readonly size: _angular_core.InputSignal<keyof FlowbiteModalSizes>;
    /**
     * @see {@link injectFlowbiteModalConfig}
     */
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            size?: {
                [x: string]: string | undefined;
                sm?: string | undefined;
                md?: string | undefined;
                lg?: string | undefined;
                xl?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    /**
     * @internal
     */
    readonly state: ng_primitives_state.CreatedState<Modal>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Modal, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Modal, "    div[flowbiteModal],    section[flowbiteModal]  ", ["flowbiteModal"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpDialog; inputs: { "id": "id"; "ngpDialogRole": "role"; "ngpDialogModal": "modal"; }; outputs: {}; }]>;
}

declare const FlowbiteModalStateToken: _angular_core.InjectionToken<Modal>;
declare const provideFlowbiteModalState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteModalState: <U = {
    readonly config: flowbite_angular_modal.FlowbiteModalConfig;
    readonly size: _angular_core.InputSignal<keyof flowbite_angular_modal.FlowbiteModalSizes>;
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            size?: {
                [x: string]: string | undefined;
                sm?: string | undefined;
                md?: string | undefined;
                lg?: string | undefined;
                xl?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    readonly state: ng_primitives_state.CreatedState<Modal>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteModalState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteModalConfig {
    /**
     * The default theme of modal
     */
    baseTheme: FlowbiteModalTheme;
    /**
     * The default size of modal
     */
    size: keyof FlowbiteSizes;
    /**
     * The custom theme of modal
     */
    customTheme: DeepPartial<FlowbiteModalTheme>;
}
declare const defaultFlowbiteModalConfig: FlowbiteModalConfig;
declare const FlowbiteModalConfigToken: InjectionToken<FlowbiteModalConfig>;
/**
 * Provide the default Modal configuration
 * @param config The Modal configuration
 * @returns The provider
 */
declare const provideFlowbiteModalConfig: (config: Partial<FlowbiteModalConfig>) => Provider[];
/**
 * Inject the Modal configuration
 * @see {@link defaultFlowbiteModalConfig}
 * @returns The configuration
 */
declare const injectFlowbiteModalConfig: () => FlowbiteModalConfig;

interface FlowbiteModalOverlayPositions extends Pick<FlowbitePositions, 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center' | 'center-left' | 'center-right'> {
    [key: string]: string;
}
interface FlowbiteModalOverlayTheme {
    host: FlowbiteModalOverlayHostTheme;
}
interface FlowbiteModalOverlayHostTheme {
    base: string;
    transition: string;
    position: FlowbiteModalOverlayPositions;
}
declare const flowbiteModalOverlayTheme: FlowbiteModalOverlayTheme;

declare class ModalOverlay {
    protected readonly config: flowbite_angular_modal.FlowbiteModalOverlayConfig;
    /**
     * @see {@link injectFlowbiteModalOverlayConfig}
     */
    readonly position: _angular_core.InputSignal<keyof FlowbiteModalOverlayPositions>;
    /**
     * @see {@link injectFlowbiteModalOverlayConfig}
     */
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            position?: {
                [x: string]: string | undefined;
                center?: string | undefined;
                'top-left'?: string | undefined;
                'top-right'?: string | undefined;
                'bottom-left'?: string | undefined;
                'bottom-right'?: string | undefined;
                'top-center'?: string | undefined;
                'bottom-center'?: string | undefined;
                'center-left'?: string | undefined;
                'center-right'?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    /**
     * @internal
     */
    readonly state: ng_primitives_state.CreatedState<ModalOverlay>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalOverlay, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalOverlay, "    div[flowbiteModalOverlay]  ", ["flowbiteModalOverlay"], { "position": { "alias": "position"; "required": false; "isSignal": true; }; "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpDialogOverlay; inputs: { "ngpDialogOverlayCloseOnClick": "closeOnClick"; }; outputs: {}; }]>;
}

declare const FlowbiteModalOverlayStateToken: _angular_core.InjectionToken<ModalOverlay>;
declare const provideFlowbiteModalOverlayState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteModalOverlayState: <U = {
    readonly config: flowbite_angular_modal.FlowbiteModalOverlayConfig;
    readonly position: _angular_core.InputSignal<keyof flowbite_angular_modal.FlowbiteModalOverlayPositions>;
    readonly customTheme: _angular_core.InputSignal<{
        host?: {
            base?: string | undefined;
            transition?: string | undefined;
            position?: {
                [x: string]: string | undefined;
                center?: string | undefined;
                'top-left'?: string | undefined;
                'top-right'?: string | undefined;
                'bottom-left'?: string | undefined;
                'bottom-right'?: string | undefined;
                'top-center'?: string | undefined;
                'bottom-center'?: string | undefined;
                'center-left'?: string | undefined;
                'center-right'?: string | undefined;
            } | undefined;
        } | undefined;
    }>;
    readonly theme: _angular_core.Signal<{
        host: {
            root: string;
        };
    }>;
    readonly state: ng_primitives_state.CreatedState<ModalOverlay>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteModalOverlayState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteModalOverlayConfig {
    /**
     * The default theme of modalOverlay
     */
    baseTheme: FlowbiteModalOverlayTheme;
    /**
     * The default position of modalOverlay
     */
    position: keyof FlowbiteModalOverlayPositions;
    /**
     * The custom theme of modalOverlay
     */
    customTheme: DeepPartial<FlowbiteModalOverlayTheme>;
}
declare const defaultFlowbiteModalOverlayConfig: FlowbiteModalOverlayConfig;
declare const FlowbiteModalOverlayConfigToken: InjectionToken<FlowbiteModalOverlayConfig>;
/**
 * Provide the default ModalOverlay configuration
 * @param config The ModalOverlay configuration
 * @returns The provider
 */
declare const provideFlowbiteModalOverlayConfig: (config: Partial<FlowbiteModalOverlayConfig>) => Provider[];
/**
 * Inject the ModalOverlay configuration
 * @see {@link defaultFlowbiteModalOverlayConfig}
 * @returns The configuration
 */
declare const injectFlowbiteModalOverlayConfig: () => FlowbiteModalOverlayConfig;

declare class ModalHeader {
    protected readonly config: flowbite_angular_modal.FlowbiteModalHeaderConfig;
    /**
     * @see {@link injectFlowbiteModalHeaderConfig}
     */
    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<ModalHeader>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalHeader, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalHeader, "    h1[flowbiteModalHeader],    h2[flowbiteModalHeader],    h3[flowbiteModalHeader],    h4[flowbiteModalHeader],    h5[flowbiteModalHeader],    h6[flowbiteModalHeader]  ", ["flowbiteModalHeader"], { "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpDialogTitle; inputs: { "id": "id"; }; outputs: {}; }]>;
}

declare const FlowbiteModalHeaderStateToken: _angular_core.InjectionToken<ModalHeader>;
declare const provideFlowbiteModalHeaderState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteModalHeaderState: <U = {
    readonly config: flowbite_angular_modal.FlowbiteModalHeaderConfig;
    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<ModalHeader>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteModalHeaderState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteModalHeaderTheme {
    host: FlowbiteModalHeaderHostTheme;
}
interface FlowbiteModalHeaderHostTheme {
    base: string;
    transition: string;
}
declare const flowbiteModalHeaderTheme: FlowbiteModalHeaderTheme;

interface FlowbiteModalHeaderConfig {
    /**
     * The default theme of modalHeader
     */
    baseTheme: FlowbiteModalHeaderTheme;
    /**
     * The custom theme of modalHeader
     */
    customTheme: DeepPartial<FlowbiteModalHeaderTheme>;
}
declare const defaultFlowbiteModalHeaderConfig: FlowbiteModalHeaderConfig;
declare const FlowbiteModalHeaderConfigToken: InjectionToken<FlowbiteModalHeaderConfig>;
/**
 * Provide the default ModalHeader configuration
 * @param config The ModalHeader configuration
 * @returns The provider
 */
declare const provideFlowbiteModalHeaderConfig: (config: Partial<FlowbiteModalHeaderConfig>) => Provider[];
/**
 * Inject the ModalHeader configuration
 * @see {@link defaultFlowbiteModalHeaderConfig}
 * @returns The configuration
 */
declare const injectFlowbiteModalHeaderConfig: () => FlowbiteModalHeaderConfig;

declare class ModalContent {
    protected readonly config: flowbite_angular_modal.FlowbiteModalContentConfig;
    /**
     * @see {@link injectFlowbiteModalContentConfig}
     */
    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<ModalContent>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalContent, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalContent, "    [flowbiteModalContent]  ", ["flowbiteModalContent"], { "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.NgpDialogDescription; inputs: { "id": "id"; }; outputs: {}; }]>;
}

declare const FlowbiteModalContentStateToken: _angular_core.InjectionToken<ModalContent>;
declare const provideFlowbiteModalContentState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteModalContentState: <U = {
    readonly config: flowbite_angular_modal.FlowbiteModalContentConfig;
    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<ModalContent>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteModalContentState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteModalContentTheme {
    host: FlowbiteModalContentHostTheme;
}
interface FlowbiteModalContentHostTheme {
    base: string;
    transition: string;
}
declare const flowbiteModalContentTheme: FlowbiteModalContentTheme;

interface FlowbiteModalContentConfig {
    /**
     * The default theme of modalContent
     */
    baseTheme: FlowbiteModalContentTheme;
    /**
     * The custom theme of modalContent
     */
    customTheme: DeepPartial<FlowbiteModalContentTheme>;
}
declare const defaultFlowbiteModalContentConfig: FlowbiteModalContentConfig;
declare const FlowbiteModalContentConfigToken: InjectionToken<FlowbiteModalContentConfig>;
/**
 * Provide the default ModalContent configuration
 * @param config The ModalContent configuration
 * @returns The provider
 */
declare const provideFlowbiteModalContentConfig: (config: Partial<FlowbiteModalContentConfig>) => Provider[];
/**
 * Inject the ModalContent configuration
 * @see {@link defaultFlowbiteModalContentConfig}
 * @returns The configuration
 */
declare const injectFlowbiteModalContentConfig: () => FlowbiteModalContentConfig;

declare class ModalFooter {
    protected readonly config: flowbite_angular_modal.FlowbiteModalFooterConfig;
    /**
     * @see {@link injectFlowbiteModalFooterConfig}
     */
    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<ModalFooter>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalFooter, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ModalFooter, "    div[flowbiteModalFooter]  ", ["flowbiteModalFooter"], { "customTheme": { "alias": "customTheme"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare const FlowbiteModalFooterStateToken: _angular_core.InjectionToken<ModalFooter>;
declare const provideFlowbiteModalFooterState: (options?: ng_primitives_state.CreateStateProviderOptions) => _angular_core.FactoryProvider;
declare const injectFlowbiteModalFooterState: <U = {
    readonly config: flowbite_angular_modal.FlowbiteModalFooterConfig;
    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<ModalFooter>;
}>(injectOptions?: _angular_core.InjectOptions) => _angular_core.Signal<ng_primitives_state.State<U>>;
declare const flowbiteModalFooterState: <U>(state: U) => ng_primitives_state.CreatedState<U>;

interface FlowbiteModalFooterTheme {
    host: FlowbiteModalFooterHostTheme;
}
interface FlowbiteModalFooterHostTheme {
    base: string;
    transition: string;
}
declare const flowbiteModalFooterTheme: FlowbiteModalFooterTheme;

interface FlowbiteModalFooterConfig {
    /**
     * The default theme of modalFooter
     */
    baseTheme: FlowbiteModalFooterTheme;
    /**
     * The custom theme of modalFooter
     */
    customTheme: DeepPartial<FlowbiteModalFooterTheme>;
}
declare const defaultFlowbiteModalFooterConfig: FlowbiteModalFooterConfig;
declare const FlowbiteModalFooterConfigToken: InjectionToken<FlowbiteModalFooterConfig>;
/**
 * Provide the default ModalFooter configuration
 * @param config The ModalFooter configuration
 * @returns The provider
 */
declare const provideFlowbiteModalFooterConfig: (config: Partial<FlowbiteModalFooterConfig>) => Provider[];
/**
 * Inject the ModalFooter configuration
 * @see {@link defaultFlowbiteModalFooterConfig}
 * @returns The configuration
 */
declare const injectFlowbiteModalFooterConfig: () => FlowbiteModalFooterConfig;

export { FlowbiteModalConfigToken, FlowbiteModalContentConfigToken, FlowbiteModalContentStateToken, FlowbiteModalFooterConfigToken, FlowbiteModalFooterStateToken, FlowbiteModalHeaderConfigToken, FlowbiteModalHeaderStateToken, FlowbiteModalOverlayConfigToken, FlowbiteModalOverlayStateToken, FlowbiteModalStateToken, Modal, ModalContent, ModalFooter, ModalHeader, ModalOverlay, defaultFlowbiteModalConfig, defaultFlowbiteModalContentConfig, defaultFlowbiteModalFooterConfig, defaultFlowbiteModalHeaderConfig, defaultFlowbiteModalOverlayConfig, flowbiteModalContentState, flowbiteModalContentTheme, flowbiteModalFooterState, flowbiteModalFooterTheme, flowbiteModalHeaderState, flowbiteModalHeaderTheme, flowbiteModalOverlayState, flowbiteModalOverlayTheme, flowbiteModalState, flowbiteModalTheme, injectFlowbiteModalConfig, injectFlowbiteModalContentConfig, injectFlowbiteModalContentState, injectFlowbiteModalFooterConfig, injectFlowbiteModalFooterState, injectFlowbiteModalHeaderConfig, injectFlowbiteModalHeaderState, injectFlowbiteModalOverlayConfig, injectFlowbiteModalOverlayState, injectFlowbiteModalState, provideFlowbiteModalConfig, provideFlowbiteModalContentConfig, provideFlowbiteModalContentState, provideFlowbiteModalFooterConfig, provideFlowbiteModalFooterState, provideFlowbiteModalHeaderConfig, provideFlowbiteModalHeaderState, provideFlowbiteModalOverlayConfig, provideFlowbiteModalOverlayState, provideFlowbiteModalState };
export type { FlowbiteModalConfig, FlowbiteModalContentConfig, FlowbiteModalContentHostTheme, FlowbiteModalContentTheme, FlowbiteModalFooterConfig, FlowbiteModalFooterHostTheme, FlowbiteModalFooterTheme, FlowbiteModalHeaderConfig, FlowbiteModalHeaderHostTheme, FlowbiteModalHeaderTheme, FlowbiteModalHostTheme, FlowbiteModalOverlayConfig, FlowbiteModalOverlayHostTheme, FlowbiteModalOverlayPositions, FlowbiteModalOverlayTheme, FlowbiteModalSizes, FlowbiteModalTheme };