import { ComponentMapping as SPAComponentMapping } from '@adobe/aem-spa-component-mapping';
import { Type } from '@angular/core';
import * as i0 from "@angular/core";
/**
 * Indicated whether force reload is turned on, forcing the model to be refetched on every MapTo instantiation.
 */
export interface ReloadForceAble {
    cqForceReload?: boolean;
}
/**
* MappedComponentProperties
* Properties given to every component runtime by the SPA editor.
*/
export interface MappedComponentProperties extends ReloadForceAble {
    /**
     * Path to the model associated with the current instance of the component
     */
    cqPath: string;
    /**
     * Angular item name
     */
    itemName: string;
}
/**
 * EditConfiguration for a MappedComponent
 * @type <P> Type  of the MappedComponent, used in isEmpty
 */
export interface EditConfig<P extends MappedComponentProperties = any> {
    /**
    * Label to display if the component is considered empty in author mode
    */
    emptyLabel?: string;
    /**
    * Return whether the component should be considered 'empty'.
    * If empty, the component will not be rendered. In author mode, the empty label will be displayed.
    * @param props
      @type <P> Type of the MappedComponent
    */
    isEmpty(props: P): boolean;
}
/**
 * Provides standard implementation for the MappedComponentProperties using @Input
 */
export declare abstract class AbstractMappedComponentDirective implements MappedComponentProperties {
    isInEditor: boolean;
    cqPath: string;
    itemName: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractMappedComponentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractMappedComponentDirective, never, never, { "isInEditor": "isInEditor"; "cqPath": "cqPath"; "itemName": "itemName"; }, {}, never>;
}
/**
 * The current class extends the @adobe/cq-spa-component-mapping#Mapto library and features with Angular specifics such as
 *
 * - Storing the editing configurations for each resource type
 */
export declare class ComponentMappingWithConfig {
    private spaMapping;
    /**
     * Store of EditConfig structures
     */
    private editConfigMap;
    constructor(spaMapping: SPAComponentMapping);
    /**
     * Stores a component class for the given resource types and also allows to provide an EditConfig object
     * @param resourceTypes - List of resource types
     * @param clazz - Component class to be stored
     * @param [editConfig] - Edit configuration to be stored for the given resource types
     * @type Model - The Model interface / class type bound to the editconfig object.
     */
    map<Model extends MappedComponentProperties = any>(resourceTypes: string | string[], clazz: Type<Model>, editConfig?: EditConfig<Model>): void;
    /**
     * Stores a  component class for the given resource types and also allows to provide an EditConfig object in a Lazy Manner
     * @param resourceTypes - List of resource types
     * @param lazyClassFunction - A function that returns a promise to give back the designated type / class
     * @param [editConfig] - Edit configuration to be stored for the given resource types
     * @type Model - The Model interface / class type bound to the editconfig object.
     */
    lazyMap<Model extends MappedComponentProperties = any>(resourceTypes: any, lazyClassFunction: () => Promise<Type<Model>>, editConfig?: EditConfig<Model>): void;
    /**
     * Returns the component class for the given resourceType
     * @param resourceType - Resource type for which the component class has been stored
     * @type Model - The Model interface / class type bound to the editconfig object.
     */
    get<Model extends MappedComponentProperties = any>(resourceType: string): Type<Model>;
    /**
       * Returns the component class Promise for the given resourceType
       * @param resourceType - Resource type for which the component class has been stored
       * @type Model - The Model interface / class type bound to the editconfig object.
       */
    lazyGet<Model extends MappedComponentProperties = any>(resourceType: string): Promise<Type<Model>>;
    /**
     * Returns the EditConfig structure for the given type
     * @param resourceType - Resource type for which the configuration has been stored
     * @type Model - The Model interface / class type bound to the editconfig object.
     */
    getEditConfig<Model extends MappedComponentProperties = any>(resourceType: string): EditConfig<Model>;
}
declare const componentMapping: ComponentMappingWithConfig;
/**
 * Stores a component class for the given resource types and also allows to provide an EditConfig object
 * @param resourceTypes - List of resource types
 * @type Model - The Model interface / class type that will be Mapped. Bound to the EditConfig configuration.
 */
declare function MapTo<Model extends MappedComponentProperties = any>(resourceTypes: string | string[]): (clazz: Type<Model>, editConfig?: EditConfig<Model>) => void;
/**
 * Stores a clazz the lazy way for dynamic imports / code splitting.function that returns a promise
 * @param resourceTypes - List of resource types
 * @type Model - The Model interface / class type that will be Mapped. Bound to the EditConfig configuration.
 */
declare function LazyMapTo<Model extends MappedComponentProperties = any>(resourceTypes: string | string[]): (lazyClassFunction: () => Promise<Type<Model>>, editConfig?: EditConfig<Model>) => void;
export { componentMapping as ComponentMapping, MapTo, LazyMapTo };