import * as _angular_core from '@angular/core';
import { Type, InjectionToken, OnDestroy, OnInit, TemplateRef, ModuleWithProviders, EnvironmentProviders } from '@angular/core';
import * as _angular_extensions_elements_src_lib_lazy_elements from '@angular-extensions/elements/src/lib/lazy-elements';

type Hook = (tag: string) => Promise<void> | void;
interface HooksConfig {
    beforeLoad?: Hook;
    afterLoad?: Hook;
}
interface ElementConfig {
    tag: string;
    url: string;
    isModule?: boolean;
    importMap?: boolean;
    loadingComponent?: Type<any>;
    errorComponent?: Type<any>;
    preload?: boolean;
    hooks?: HooksConfig;
    isAdded?: boolean;
}
interface LazyElementsRegistry extends Map<string, Promise<void>> {
    get: (url: string) => Promise<void> | undefined;
    set: (url: string, notifier: Promise<void>) => this;
    has: (url: string) => boolean;
}
interface LazyElementModuleOptions {
    elementConfigs?: ElementConfig[];
}
interface LazyElementModuleRootOptions {
    elementConfigs?: ElementConfig[];
    rootOptions?: LazyElementRootOptions;
}
interface LazyElementRootOptions {
    loadingComponent?: Type<any>;
    errorComponent?: Type<any>;
    isModule?: boolean;
    importMap?: boolean;
    preload?: boolean;
    hooks?: HooksConfig;
}
interface LazyElementOptions {
    elementConfigs?: ElementConfig[];
    rootOptions?: LazyElementRootOptions;
}

declare const LAZY_ELEMENT_CONFIGS: InjectionToken<ElementConfig[]>;
declare const LAZY_ELEMENT_ROOT_OPTIONS: InjectionToken<LazyElementRootOptions>;
declare const LAZY_ELEMENT_ROOT_GUARD: InjectionToken<void>;
declare const LAZY_ELEMENTS_REGISTRY: InjectionToken<LazyElementsRegistry>;

declare class LazyElementsLoaderService implements OnDestroy {
    #private;
    static controller: AbortController;
    readonly options: _angular_extensions_elements_src_lib_lazy_elements.LazyElementRootOptions;
    configs: ElementConfig[];
    ngOnDestroy(): void;
    addConfigs(newConfigs: ElementConfig[]): void;
    getElementConfig(tag: string): ElementConfig | undefined;
    preload(tags?: string[]): void;
    loadElement(url: string | null, tag: string, isModule?: boolean, importMap?: boolean, hooksConfig?: HooksConfig): Promise<void>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LazyElementsLoaderService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LazyElementsLoaderService>;
}

declare class LazyElementDirective implements OnInit {
    #private;
    readonly url: _angular_core.InputSignal<string>;
    readonly loadingTemplateRef: _angular_core.InputSignal<TemplateRef<any>>;
    readonly errorTemplateRef: _angular_core.InputSignal<TemplateRef<any>>;
    readonly isModule: _angular_core.InputSignal<boolean>;
    readonly importMap: _angular_core.InputSignal<boolean>;
    readonly loadingSuccess: _angular_core.InputSignal<() => void>;
    readonly loadingError: _angular_core.InputSignal<(error: ErrorEvent) => void>;
    ngOnInit(): void;
    destroyEmbeddedView(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LazyElementDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LazyElementDirective, "[axLazyElement]", never, { "url": { "alias": "axLazyElement"; "required": false; "isSignal": true; }; "loadingTemplateRef": { "alias": "axLazyElementLoadingTemplate"; "required": false; "isSignal": true; }; "errorTemplateRef": { "alias": "axLazyElementErrorTemplate"; "required": false; "isSignal": true; }; "isModule": { "alias": "axLazyElementModule"; "required": false; "isSignal": true; }; "importMap": { "alias": "axLazyElementImportMap"; "required": false; "isSignal": true; }; "loadingSuccess": { "alias": "axLazyElementLoadingSuccess"; "required": false; "isSignal": true; }; "loadingError": { "alias": "axLazyElementLoadingError"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LazyElementDynamicDirective implements OnInit {
    #private;
    readonly tag: _angular_core.InputSignal<string>;
    readonly url: _angular_core.InputSignal<string>;
    readonly loadingTemplateRef: _angular_core.InputSignal<TemplateRef<any>>;
    readonly errorTemplateRef: _angular_core.InputSignal<TemplateRef<any>>;
    readonly isModule: _angular_core.InputSignal<boolean>;
    readonly importMap: _angular_core.InputSignal<boolean>;
    readonly loadingSuccess: _angular_core.InputSignal<() => void>;
    readonly loadingError: _angular_core.InputSignal<(error: ErrorEvent) => void>;
    ngOnInit(): void;
    destroyEmbeddedView(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LazyElementDynamicDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LazyElementDynamicDirective, "[axLazyElementDynamic]", never, { "tag": { "alias": "axLazyElementDynamic"; "required": false; "isSignal": true; }; "url": { "alias": "axLazyElementDynamicUrl"; "required": false; "isSignal": true; }; "loadingTemplateRef": { "alias": "axLazyElementDynamicLoadingTemplate"; "required": false; "isSignal": true; }; "errorTemplateRef": { "alias": "axLazyElementDynamicErrorTemplate"; "required": false; "isSignal": true; }; "isModule": { "alias": "axLazyElementDynamicModule"; "required": false; "isSignal": true; }; "importMap": { "alias": "axLazyElementDynamicImportMap"; "required": false; "isSignal": true; }; "loadingSuccess": { "alias": "axLazyElementLoadingSuccess"; "required": false; "isSignal": true; }; "loadingError": { "alias": "axLazyElementLoadingError"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare function createLazyElementRootGuard(rootOptions: LazyElementRootOptions): string;
declare class LazyElementsModule {
    static forRoot(options: LazyElementModuleRootOptions): ModuleWithProviders<LazyElementsModule>;
    static forFeature(options: LazyElementModuleOptions): ModuleWithProviders<LazyElementsModule>;
    readonly lazyElementsLoaderService: LazyElementsLoaderService;
    readonly elementConfigsMultiProvider: ElementConfig[][];
    readonly guard: void;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LazyElementsModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<LazyElementsModule, never, [typeof LazyElementDirective, typeof LazyElementDynamicDirective], [typeof LazyElementDirective, typeof LazyElementDynamicDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<LazyElementsModule>;
}

declare function createProvideLazyElementsGuard(rootOptions: LazyElementRootOptions): string;
declare function provideAxLazyElements(options?: LazyElementOptions): EnvironmentProviders;
declare function provideAxLazyElementsConfigs(configs?: ElementConfig[]): EnvironmentProviders;

export { LAZY_ELEMENTS_REGISTRY, LAZY_ELEMENT_CONFIGS, LAZY_ELEMENT_ROOT_GUARD, LAZY_ELEMENT_ROOT_OPTIONS, LazyElementDirective, LazyElementDynamicDirective, LazyElementsLoaderService, LazyElementsModule, createLazyElementRootGuard, createProvideLazyElementsGuard, provideAxLazyElements, provideAxLazyElementsConfigs };
export type { ElementConfig, Hook, HooksConfig, LazyElementModuleOptions, LazyElementModuleRootOptions, LazyElementOptions, LazyElementRootOptions, LazyElementsRegistry };