import * as i0 from '@angular/core';
import { PipeTransform, InjectionToken, TemplateRef, Type, OnDestroy, Signal, EffectCleanupRegisterFn, CreateEffectOptions, EffectRef, InputOptionsWithTransform } from '@angular/core';
import { UrlTree, ActivatedRoute, Params } from '@angular/router';
export { DecorativePalette, PrClass as LuClass, Palette } from '@lucca/prisme/core';

/**
 * Extracts the values of an enum as a union type.
 *
 * @example
 * ```ts
 * enum ExampleEnum {
 *    A = 'a',
 *    B = 'b',
 * }
 *
 * type ExampleEnumValue = EnumValue<typeof ExampleEnum>; // Same as 'a' | 'b'
 * ```
 */
type EnumValue<T> = `${T[keyof T] & string}`;

declare class LuTypeGuardPipe implements PipeTransform {
    transform<T, U extends T>(obj: T, typeGuardFn: (arg: T) => arg is U): obj is U;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuTypeGuardPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LuTypeGuardPipe, "luTypeGuard", true>;
}

type At = 'media' | 'container';
type Breakpoint = 'XXXS' | 'XXS' | 'XS' | 'S' | 'M' | 'L' | 'XL' | 'XXL' | 'XXXL';
/**
 * Breakpoints in em, useful for media queries
 *
 * Equivalent of `$breakpoints` (from scss/src/commons/config.scss)
 */
declare const defaultBreakpoints: {
    readonly XXXS: "20em";
    readonly XXS: "30em";
    readonly XS: "40em";
    readonly S: "50em";
    readonly M: "64em";
    readonly L: "80em";
    readonly XL: "85.375em";
    readonly XXL: "100em";
    readonly XXXL: "120em";
};
type ResponsiveConfig<T extends string, V> = Partial<Record<ResponsiveProperty<T>, V>>;
type ResponsiveProperty<T extends string> = `${T}At${Capitalize<At>}Min${Breakpoint}`;

declare enum ELuDateGranularity {
    day = "day",
    month = "month",
    year = "year",
    decade = "decade"
}
type LuDateGranularity = EnumValue<ELuDateGranularity>;

interface ILuDateAdapter<D> {
    forge(year: number, month: number, date: number): D;
    forgeToday(): D;
    forgeInvalid(): D;
    isValid(d: D): boolean;
    compare(a: D, b: D, granularity: LuDateGranularity): number;
    isParsable(text: string, granularity?: LuDateGranularity): boolean;
    parse(text: string, granularity?: LuDateGranularity): D;
    format(d: D, format: string): string;
    clone(d: D): D;
    getYear(d: D): number;
    getMonth(d: D): number;
    getDate(d: D): number;
    getDay(d: D): number;
    add(d: D, count: number, granularity: LuDateGranularity): D;
}

declare abstract class ALuDateAdapter<D> implements ILuDateAdapter<D> {
    abstract forge(year: number, month: number, date: number): D;
    abstract forgeToday(): D;
    abstract forgeInvalid(): D;
    abstract isValid(d: D): boolean;
    compare(a: D, b: D, granularity: LuDateGranularity): number;
    abstract isParsable(text: string, granularity?: LuDateGranularity): boolean;
    abstract parse(text: string, granularity?: LuDateGranularity): D;
    abstract format(d: D, format: string): string;
    abstract clone(d: D): D;
    abstract getYear(d: D): number;
    abstract getMonth(d: D): number;
    abstract getDate(d: D): number;
    abstract getDay(d: D): number;
    abstract add(d: D, count: number, granularity: LuDateGranularity): D;
}

interface ILuNativeDateAdapterOptions {
    useUtc?: boolean;
}
declare const luDefaultNativeDateAdapterOptions: ILuNativeDateAdapterOptions;
declare const LU_NATIVE_DATE_ADAPTER_OPTIONS: InjectionToken<ILuNativeDateAdapterOptions>;

declare class LuNativeDateAdapter extends ALuDateAdapter<Date> implements ILuDateAdapter<Date> {
    private _locale;
    private _options;
    private _regex;
    private _order;
    constructor(_locale: string, _options: ILuNativeDateAdapterOptions);
    private initOrder;
    private extract;
    isParsable(text: string, granularity?: LuDateGranularity): boolean;
    parse(text: string, granularity?: LuDateGranularity): Date;
    format(d: Date, format: string): string;
    forge(year: number, month: number, date: number): Date;
    forgeToday(): Date;
    forgeInvalid(): Date;
    isValid(d: Date): boolean;
    clone(d: Date): Date;
    getYear(d: Date): number;
    getMonth(d: Date): number;
    getDate(d: Date): number;
    getDay(d: Date): number;
    add(d: Date, count: number, granularity: LuDateGranularity): Date;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuNativeDateAdapter, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuNativeDateAdapter>;
}

/** bind to a string with iso 26001 format YYYY-MM-DD */
declare class LuStringDateAdapter extends ALuDateAdapter<string> implements ILuDateAdapter<string> {
    private _locale;
    private _nativeAdapter;
    constructor(_locale: string);
    forge(year: number, month: number, date: number): string;
    forgeToday(): string;
    forgeInvalid(): string;
    isValid(d: string): boolean;
    compare(a: string, b: string, granularity: LuDateGranularity): number;
    isParsable(text: string): boolean;
    parse(text: string, granularity: LuDateGranularity): string;
    format(d: string, format: string): string;
    clone(d: string): string;
    getYear(d: string): number;
    getMonth(d: string): number;
    getDate(d: string): number;
    getDay(d: string): number;
    add(d: string, count: number, granularity: LuDateGranularity): string;
    protected stringToDate(s: string): Date;
    protected dateToString(d: Date): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuStringDateAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuStringDateAdapter>;
}

interface ILuOnCloseSubscriber {
    onClose(): void;
}
declare abstract class ALuOnCloseSubscriber implements ILuOnCloseSubscriber {
    abstract onClose(): void;
}

interface ILuOnOpenSubscriber {
    onOpen(): void;
}
declare abstract class ALuOnOpenSubscriber implements ILuOnOpenSubscriber {
    abstract onOpen(): void;
}

interface ILuOnScrollBottomSubscriber {
    onScrollBottom(): void;
}
declare abstract class ALuOnScrollBottomSubscriber implements ILuOnScrollBottomSubscriber {
    abstract onScrollBottom(): void;
}

interface ILuGroup<TItem, TKey> {
    key: TKey;
    items: TItem[];
}

declare function generateId(): string;

type Nil = null | undefined;
declare const isNil: <T>(value: T | Nil) => value is Nil;
declare const isNotNil: <T>(value: T) => value is NonNullable<T>;
declare const isNilOrEmptyString: (str: string | Nil) => str is Nil | "";
declare const isNotNilOrEmptyString: (str: string | Nil) => str is string;

type PortalContent<T = unknown> = string | TemplateRef<T> | Type<unknown>;
declare const PORTAL_CONTEXT: InjectionToken<unknown>;

declare class PortalDirective<T = unknown> implements OnDestroy {
    private viewContainerRef;
    private renderer;
    private templateRef;
    private injector;
    luPortal: i0.InputSignal<PortalContent<T>>;
    luPortalContext: i0.InputSignal<T>;
    private createdTextElement;
    private embeddedViewRef?;
    private componentRef?;
    constructor();
    private render;
    ngOnDestroy(): void;
    private renderText;
    private destroyRenderedText;
    /**
     * Embeded view context should not be overwritten, but updated.
     * @see https://github.com/angular/angular/pull/51887
     */
    private updateEmbeddedViewContext;
    static ngTemplateContextGuard<T>(_dir: PortalDirective<T>, ctx: unknown): ctx is void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortalDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PortalDirective<any>, "[luPortal]", never, { "luPortal": { "alias": "luPortal"; "required": true; "isSignal": true; }; "luPortalContext": { "alias": "luPortalContext"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * `RouterLinkParam` is an interface that mirrors the options you can pass to Angular `routerLink` helpers.
 * Commands refers to the link parameters array
 * https://angular.dev/api/router/RouterLink
 */
interface RouterLinkParam {
    commands: string | readonly string[] | UrlTree | null | undefined;
    relativeTo?: ActivatedRoute | null | undefined;
    queryParams?: Params | null | undefined;
    target?: string | undefined;
    fragment?: string | undefined;
    preserveFragment?: boolean;
    skipLocationChange?: boolean;
    replaceUrl?: boolean;
}

declare function isRouterLinkParam(routerLinkParam: RouterLinkParam | string | readonly string[] | UrlTree | null | undefined): routerLinkParam is RouterLinkParam;

type SignalsValue<T> = T extends readonly unknown[] ? TupleOfSignalValues<T> : [RecordOfSignalValues<T>];
type TupleOfSignalValues<T> = T extends readonly [Signal<infer U>, ...infer R] ? [U, ...TupleOfSignalValues<R>] : [];
type RecordOfSignalValues<T> = {
    [K in keyof T]: T[K] extends Signal<infer U> ? U : never;
};
type EffectWithDepsInput = ReadonlyArray<Signal<unknown>> | Record<string, Signal<unknown>>;
/**
 * Effect peut être dangereux car l'action accomplie peut elle-même déclencher des écritures dans des signaux.
 * C'est une mauvaise pratique, interdite par défaut par Angular.
 * La plupart du temps, seule la lecture des signaux est intéressante à tracker, pas les actions qui en découlent.
 */
declare function ɵeffectWithDeps<const T extends EffectWithDepsInput>(dependencies: T, action: (...values: [...SignalsValue<T>, EffectCleanupRegisterFn]) => unknown, options?: CreateEffectOptions): EffectRef;

/**
 * @deprecated use `LuTranslation` instead.
 */
interface ILuTranslation<T> {
    en: T;
    fr: T;
    'en-GB'?: T;
    'en-US'?: T;
    es?: T;
    de?: T;
    pt?: T;
}
type LuTranslation<T> = Record<string, T>;

declare function getIntl<T>(translationsToken: InjectionToken<LuTranslation<T>> | InjectionToken<ILuTranslation<T>>): T;
/**
 * Creates configuration for an Angular signal input that supports internationalization with optional overrides.
 *
 * This function merges translations from one or more injection tokens and returns a tuple
 * compatible with Angular's `input()` function. Users can override specific translations
 * via the component's `[intl]` input while inheriting defaults from the provided tokens.
 *
 * @example
 * ```typescript
 * // In a component
 * intl = input(...intlInputOptions(LU_SOME_COMPONENT_TRANSLATIONS));
 *
 * // Usage in template
 * <lu-some-component [intl]="{ stuff: 'Some custom stuff' }" />
 * ```
 *
 * @param tokens - One or more injection tokens containing locale-based translations
 * @returns A tuple of [defaultValue, inputOptions] to spread into Angular's `input()` function
 */
declare function intlInputOptions<T1>(token1: InjectionToken<LuTranslation<T1>>): [T1, InputOptionsWithTransform<T1, Partial<T1>>];
declare function intlInputOptions<T1, T2>(token1: InjectionToken<LuTranslation<T1>>, token2: InjectionToken<LuTranslation<T2>>): [T1 & T2, InputOptionsWithTransform<T1 & T2, Partial<T1 & T2>>];

declare class IntlParamsPipe implements PipeTransform {
    #private;
    transform(value: string, args: Record<string, string | number>): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<IntlParamsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IntlParamsPipe, "intlParams", true>;
}

interface ILuTree<T> {
    value: T;
    children: ILuTree<T>[];
    disabled?: boolean;
}

export { ALuDateAdapter, ALuOnCloseSubscriber, ALuOnOpenSubscriber, ALuOnScrollBottomSubscriber, ELuDateGranularity, IntlParamsPipe, LU_NATIVE_DATE_ADAPTER_OPTIONS, LuNativeDateAdapter, LuStringDateAdapter, LuTypeGuardPipe, PORTAL_CONTEXT, PortalDirective, defaultBreakpoints, generateId, getIntl, intlInputOptions, isNil, isNilOrEmptyString, isNotNil, isNotNilOrEmptyString, isRouterLinkParam, luDefaultNativeDateAdapterOptions, ɵeffectWithDeps };
export type { At, Breakpoint, EffectWithDepsInput, EnumValue, ILuDateAdapter, ILuGroup, ILuNativeDateAdapterOptions, ILuOnCloseSubscriber, ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber, ILuTranslation, ILuTree, LuDateGranularity, LuTranslation, PortalContent, ResponsiveConfig, ResponsiveProperty, RouterLinkParam };