EDIT

/**

* Copyright (C) 2007 EDIT

* See LICENSE.TXT at the top of this package for the full license terms.

*/

import eu.etaxonomy.cdm.model.common.LanguageStringBase;

import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;

import eu.etaxonomy.cdm.model.location.NamedAreaType;

import eu.etaxonomy.cdm.model.media.Media;

     * Returns a term according to it's uri

     * @param uri

     * @return

     */

    public DefinedTermBase getByUri(URI uri);

    public UUID saveLanguageData(LanguageStringBase languageData);

    public List<LanguageString> getAllLanguageStrings(int limit, int start);

    public List<Representation> getAllRepresentations(int limit, int start);

    public Language getLanguageByIso(String iso639);

    public List<Language> getLanguagesByLocale(Enumeration<Locale> locales);

    public NamedArea getAreaByTdwgAbbreviation(String tdwgAbbreviation);

     /**

     * @param definedTerm the definedTerm represented by these media

     * @param pageSize The maximum number of media returned (can be null for all related media)

     * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     */

    /**

     * Returns a paged list of NamedArea instances (optionally filtered by type or level)

     *

     * @param level restrict the result set to named areas of a certain level (can be null)

     * @param type restrict the result set to named areas of a certain type (can be null)

     * @param pageSize The maximum number of namedAreas returned (can be null for all named areas)

     * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     * @return a Pager of named areas

     */

    public Pager<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber,  List<OrderHint> orderHints, List<String> propertyPaths);

    /**

     * Return a paged list of terms which are specializations of a given definedTerm

     *

     * @param definedTerm The term which is a generalization of the terms returned

     * @param pageSize The maximum number of terms returned (can be null for all specializations)

     * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     * @return a Pager of DefinedTerms

     */

    public <T extends DefinedTermBase> Pager<T> getGeneralizationOf(T definedTerm, Integer pageSize, Integer pageNumber);

    /**

     * Return a paged list of distinct terms which include the terms supplied

     *

     * @param definedTerms the set of terms which are part of the terms of interest

     * @param pageSize The maximum number of terms returned (can be null for all terms)

     * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     * @param propertyPaths properties to initialize - see {@link IBeanInitializer#initialize(Object, List)}

     * @return a Pager of DefinedTerms

     */

    public <T extends DefinedTermBase> Pager<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths);

    /**

     * Return a paged list of terms which are part of the terms supplied

     *

     * @param definedTerms the set of terms which include the terms of interest

     * @param pageSize The maximum number of terms returned (can be null for all terms)

     * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     * @param propertyPaths properties to initialize - see {@link IBeanInitializer#initialize(Object, List)}

     * @return a Pager of DefinedTerms

     */

    /**

     * Return a paged list of terms which have representations that match the supplied string in the text (description)

     *

     * @param label a string to match (exactly)

     * @param pageSize The maximum number of terms returned (can be null for all terms)

     * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     * @return a Pager of DefinedTerms

     */

    public <T extends DefinedTermBase> Pager<T> findByRepresentationText(String label, Class<T> clazz,  Integer pageSize, Integer pageNumber);

    /**

     * Return a paged list of terms which have representations that match the supplied string in the abbreviated label

     *

     * @param label a string to match (exactly)

     * @param pageSize The maximum number of terms returned (can be null for all terms)

     * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     * @return a Pager of DefinedTerms

     */

    public <T extends DefinedTermBase> Pager<T> findByRepresentationAbbreviation(String abbrev, Class<T> clazz, Integer pageSize, Integer pageNumber);

     * Retrieves all {@link DefinedTermBase}s with the given {@link TermType}

     * @param termType the term type to filter the terms

     * @param limit

     * @param start

     * @param orderHints

     * @param propertyPaths

     * @return a list containing the terms

     */

     * Delete the given term according to the given delete configuration.

     * In case a problem occurrs while deleting the term the result will reflect this

     * via its status.

     * @param term the term to delete

     * @param config the configurator

     * @return DeleteResult which holds the status of the deletion.

     */

    public DeleteResult delete(DefinedTermBase term, TermDeletionConfigurator config);

     * Returns the term with the given idInVocabulary for the given vocabulary.

     * contract of idInVocabulary) always the same term should be returned.

     * @param vocabularyUuid uuid of vocabulary

    /**

     * @param termUuid

     * @param config

     * @return

     */

    public DeleteResult delete(UUID termUuid, TermDeletionConfigurator config);

    /**

     * @param label

     * @return

     */

    public Language getLanguageByLabel(String label);

    /**

     * @param representations

     * @return

     */

    public Map<UUID, Representation> saveOrUpdateRepresentations(Collection<Representation> representations);

     * @param vocs

     * @param limit

     * @param pattern

     */

            Language lang);

    /**

     * Returns all terms that are included in the given parent term resp. a part of the given term.

     * @param parentTerm the parent term

     * @return a collection of included terms

     */

    public Collection<TermDto> getIncludesAsDto(TermDto parentTerm);

    /**

     * Returns all terms that the given term is a generalization of resp. that are a kind of the given term

     * @param parentTerm the parent term

     * @return a collection of included terms

     */

    public Collection<TermDto> getKindOfsAsDto(TermDto parentTerm);

    /**

     * Move the given term to the given parent

     * @param termDto the {@link TermDto} of the term to move

     * @param parentUuid the {@link UUID} of the new parent term

     * @param termMovePosition enum to specify the position for {@link OrderedTermBase}s in an {@link OrderedTermVocabulary}

     */

    public void moveTerm(TermDto termDto, UUID parentUuid, TermMovePosition termMovePosition);

    /**

     * Move the given term to the given parent

     * @param termDto the {@link TermDto} of the term to move

     * @param parentUuid the {@link UUID} of the new parent term

     */

    public void moveTerm(TermDto termDto, UUID parentUuid);

    /**

     * Creates a new term as a child of the given parent.

     * @param termType the {@link TermType} of the term to create

     * @param parentUuid the {@link UUID} of the parent term

     * @param isKindOf if <code>true</code> the term will be added via a

     * kindOf relation. Otherwise it will added via a partOf relation