import { NormalisedProfile, NormalisedEntityDefinition, ProfileLayout, ProfileInput, EntityReference } from '../types';
/**
 * @class
 *
 * ProfileManager
 *
 * A class to work with Recrate Profiles
 *
 * @param {profile} - profile to handle
 */
export declare class ProfileManager {
    profile?: NormalisedProfile;
    $key?: number;
    context?: any;
    propertyDefinitionCache: Map<string, ProfileInput>;
    constructor({ profile }: {
        profile?: NormalisedProfile;
    });
    /**
     * Process input definitions for certain types.
     *
     * For now it takes care of setting 'handlesMultipleValues' for input types, which can have multiple values
     * but handle all values themselves and not require a new render property added for each new value. This is the
     * case for checbox style selects. It provides the same functionality as a normal select but all values are
     * visible and selectable at once and not one by one.
     *
     * It also makes sure that for radio style selects "multiple" is always set to "false", as radio input only
     * provides a single value selected form many.
     *
     * @private
     */
    private __processInputs;
    /**
     *
     * Get the layout for an entity from the profile
     *
     * Returns the first matching layout from the profile
     *
     * @param { Object } options
     * @param { Object } options.entity - the entity whose layout is required
     *
     */
    getLayout({ entity, }: {
        entity: NormalisedEntityDefinition | EntityReference;
    }): ProfileLayout | null;
    /**
     * Get inverse associations from the profile if any are defined
     */
    getPropertyAssociations(): {
        [key: string]: {
            property: string;
            propertyId: string;
        };
    };
    /**
     *
     * Get the available classes
     *   if a profile is defined, get those
     *
     * Returns the classes defined in the profile if one is applied
     *   or all of the classes built into the base, schema.org profile
     *
     */
    getClasses(): string[];
    /**
     *
     * Return the type hierarchy for the given entity
     *
     * @param { Object } options
     * @param { Object } options.entity - the entity whose hierarchy is required
     *
     *
     */
    getEntityTypeHierarchy({ entity }: {
        entity: NormalisedEntityDefinition;
    }): string[];
    /**
     *
     * Given an entity, try to find a definition for the property in the profile or
     *  right across the hierarchy
     *
     * @param { Object } options
     * @param { Object } options.property - the property to define
     * @param { Object } options.entity - the entity this property is a part of
     *
     */
    getPropertyDefinition({ property, entity, }: {
        property: string;
        entity: NormalisedEntityDefinition;
    }): {
        propertyDefinition: ProfileInput;
    };
    /**
     *
     * Given a set of types, figure out the type hierarchy taking into account
     *  the parent types that this is a subClassOf
     */
    mapTypeHierarchies({ types }: {
        types: string[];
    }): string[];
    /**
     *
     * Given an entity, get the inputs defined in the profile
     *
     * @param { Object } options
     * @param { Object } options.entity - the entity
     *
     */
    getInputsFromProfile({ entity }: {
        entity: NormalisedEntityDefinition;
    }): ProfileInput[];
    /**
     *
     * Given an entity, get all available inputs by joining the profile with schema.org
     *
     * @param { Object } options
     * @param { Object } options.entity - the entity
     */
    getAllInputs({ entity }: {
        entity: NormalisedEntityDefinition;
    }): {
        inputs: ProfileInput[];
    };
    /**
     *
     * Try to get a definition from the profile and see if it's override or inherit
     *
     * If there's an override then return override - otherwise inherit. Exclusive rather than inclusive.
     *
     * @param { Object } options
     * @param { Object } options.entity - the entity
     * if there's an override then set to override - otherwise inherit
     * be exclusive rather than inclusive
     */
    getTypeDefinition({ entity }: {
        entity: NormalisedEntityDefinition;
    }): "inherit" | "override";
    /**
     * Get an entity label if defined
     *
     * @property the type name to localise
     */
    getTypeLabel(type: string): string;
}
