import * as _angular_core from '@angular/core';
import { Type, ApplicationRef, ComponentRef, Signal, ApplicationConfig, ComponentMirror, InputSignal, WritableSignal, PlatformRef, StaticProvider } from '@angular/core';

/**
 * Creates and destroys a component ref using a component factory and handles change detection
 * in response to input changes.
 */
declare class NgElementumStrategy {
    private component;
    private appRef;
    /** Reference to the component that was created on connect. */
    private componentRef;
    /** Callback function that when called will cancel a scheduled destruction on the component. */
    private scheduledDestroy;
    /** Initial input values that were set before the component was created. */
    private readonly initialInputValues;
    /**
     * Angular's change detection scheduler, which works independently of zone.js.
     */
    private cdScheduler;
    private readonly inputMap;
    private readonly componentMirror;
    constructor(component: Type<any>, appRef: ApplicationRef);
    /**
     * Initializes a new component if one has not yet been created and cancels any scheduled
     * destruction.
     */
    connect(element: HTMLElement): void;
    /**
     * Schedules the component to be destroyed after some small delay in case the element is just
     * being moved across the DOM.
     */
    disconnect(): void;
    /**
     * Returns the component property value. If the component has not yet been created, the value is
     * retrieved from the cached initialization values.
     */
    getValue(property: string): any;
    /**
     * Sets the input value for the property. If the component has not yet been created, the value is
     * cached and set when the component is created.
     */
    setValue(property: string, value: any): void;
    applyMethod(methodName: keyof any, args: any[]): any;
    /**
     * Creates a new component through the component factory with the provided element host and
     * sets up its initial inputs, listens for outputs changes, and runs an initial change detection.
     */
    protected initializeComponent(element: HTMLElement): void;
    /** Sets up listeners for the component's outputs so that the events stream emits the events. */
    protected initializeOutputs(element: HTMLElement, componentRef: ComponentRef<any>): void;
}

/**
 * Prototype for a class constructor based on an Angular component
 * that can be used for custom element registration. Implemented and returned
 * by the {@link createCustomElement createCustomElement() function}.
 *
 * @see [Angular Elements Overview](guide/elements "Turning Angular components into custom elements")
 *
 * @publicApi
 */
interface NgElementumConstructor<T, M extends keyof T, S extends keyof T> {
    /**
     * Initializes a constructor instance.
     */
    new (): NgElementum & ExposeInputs<T> & ExposeSignals<T, S> & ExposeMethods<T, M>;
}
/**
 * Implements the functionality needed for a custom element.
 *
 * @publicApi
 */
declare abstract class NgElementum extends HTMLElement {
    #private;
    constructor(componentType: ComponentMirror<any>, config: NgElementumConfig<string, string>);
    /**
     * Prototype for a handler that responds to a change in an observed attribute.
     * @param attrName The name of the attribute that has changed.
     * @param oldValue The old value of the attribute.
     * @param newValue The new value of the attribute.
     * @returns Nothing.
     */
    attributeChangedCallback(attrName: string, oldValue: string, newValue: string): void;
    /**
     * Prototype for a handler that responds to the insertion of the custom element in the DOM.
     * @returns Nothing.
     */
    connectedCallback(): void;
    /**
     * Prototype for a handler that responds to the deletion of the custom element from the DOM.
     * @returns Nothing.
     */
    disconnectedCallback(): void;
    protected ngElementumGetValue(propName: string): any;
    protected ngElementumSetValue(propName: string, newValue: string): void;
    setSignalValue(propName: string, newValue: string): void;
    remove(): void;
    attachShadow(init: ShadowRootInit): ShadowRoot;
    protected get ngElementumCachedStrategy(): NgElementumStrategy | undefined;
}
type ExtractMethods<T> = {
    [K in keyof T]: K extends string ? T[K] extends (...args: any[]) => any ? T[K] extends Signal<any> ? never : K : never : never;
}[keyof T];
type ExtractSignals<T> = {
    [K in keyof T]: K extends string ? T[K] extends Signal<any> ? K : never : never;
}[keyof T];
type UnwrapSignal<T> = T extends Signal<infer V> ? V | null : never;
type ExposeInputs<T> = {
    -readonly [K in keyof T as T[K] extends InputSignal<any> ? K : never]: UnwrapSignal<T[K]>;
};
type ExposeMethods<T, M extends keyof T> = {
    [K in keyof T as M extends K ? K : never]: T[K] extends (...args: infer A) => infer R ? (...args: A) => R extends Promise<any> ? R : Promise<R> : never;
};
type ExposeSignals<T, S extends keyof T> = {
    readonly [K in keyof T as S extends K ? T[K] extends Signal<any> ? T[K] extends WritableSignal<any> ? never : K : never : never]: UnwrapSignal<T[K]>;
} & {
    -readonly [K in keyof T as S extends K ? T[K] extends WritableSignal<any> ? K : never : never]: UnwrapSignal<T[K]>;
};
/**
 * A configuration that initializes an NgElementConstructor with the
 * dependencies and strategy it needs to transform a component into
 * a custom element class.
 *
 * @publicApi
 */
type NgElementumConfig<M extends string, S extends string> = {
    /**
     * An optional list of methods to expose on the custom element.
     */
    exposedMethods?: M[];
    /**
     * An optional list of signals to expose on the custom element.
     */
    exposedSignals?: S[];
    /**
     * The config for application.
     *
     * If function passed, it will be called within the platform injection context.
     */
    applicationConfig: ApplicationConfig | (() => ApplicationConfig);
};
/**
 *  @description Creates a custom element class based on an Angular component.
 *
 * Builds a class that encapsulates the functionality of the provided component and
 * uses the configuration information to provide more context to the class.
 * Takes the component factory's inputs and outputs to convert them to the proper
 * custom element API and add hooks to input changes.
 *
 * The configuration's injector is the initial injector set on the class,
 * and used by default for each created instance.This behavior can be overridden with the
 * static property to affect all newly created instances, or as a constructor argument for
 * one-off creations.
 *
 * @see [Angular Elements Overview](guide/elements "Turning Angular components into custom elements")
 *
 * @param component The component to transform.
 * @param config A configuration that provides initialization information to the created class.
 * @returns The custom-element construction class, which can be registered with
 * a browser's `CustomElementRegistry`.
 *
 * @publicApi
 */
declare function createCustomElement<T, const M extends ExtractMethods<T>, const S extends ExtractSignals<T>>(component: Type<T>, config: NgElementumConfig<M, S>): NgElementumConstructor<T, M, S>;

declare const platformElementum: (extraProviders?: _angular_core.StaticProvider[]) => PlatformRef;

declare function createApplicationSync(applicationConfig: ApplicationConfig): ApplicationRef;

declare function providePlatformEffectInterop(): StaticProvider[];

declare function providePlatformResourceInterop(): StaticProvider[];

export { NgElementum, createCustomElement, platformElementum, createApplicationSync as ɵcreateApplicationSync, providePlatformEffectInterop as ɵprovidePlatformEffectInterop, providePlatformResourceInterop as ɵprovidePlatformResourceInterop };
export type { NgElementumConfig, NgElementumConstructor };