LayoutSetVersionPersistence

All Superinterfaces:

BasePersistence<LayoutSetVersion>
```
@ProviderType
public interface LayoutSetVersionPersistence
extends BasePersistence<LayoutSetVersion>
```
The persistence interface for the layout set version service.
Caching information and settings can be found in portal.properties

Author:

Brian Wing Shun Chan

See Also:

LayoutSetVersionUtil

Generated:

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`cacheResult(LayoutSetVersion layoutSetVersion)` Caches the layout set version in the entity cache if it is enabled.
`void`	`cacheResult(java.util.List<LayoutSetVersion> layoutSetVersions)` Caches the layout set versions in the entity cache if it is enabled.
`int`	`countAll()` Returns the number of layout set versions.
`int`	`countByG_P_Version(long groupId, boolean privateLayout, int version)` Returns the number of layout set versions where groupId = ? and privateLayout = ? and version = ?.
`int`	`countByG_P(long groupId, boolean privateLayout)` Returns the number of layout set versions where groupId = ? and privateLayout = ?.
`int`	`countByGroupId_Version(long groupId, int version)` Returns the number of layout set versions where groupId = ? and version = ?.
`int`	`countByGroupId(long groupId)` Returns the number of layout set versions where groupId = ?.
`int`	`countByLayoutSetId_Version(long layoutSetId, int version)` Returns the number of layout set versions where layoutSetId = ? and version = ?.
`int`	`countByLayoutSetId(long layoutSetId)` Returns the number of layout set versions where layoutSetId = ?.
`int`	`countByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid, int version)` Returns the number of layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`int`	`countByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)` Returns the number of layout set versions where layoutSetPrototypeUuid = ?.
`int`	`countByP_L_Version(boolean privateLayout, long logoId, int version)` Returns the number of layout set versions where privateLayout = ? and logoId = ? and version = ?.
`int`	`countByP_L(boolean privateLayout, long logoId)` Returns the number of layout set versions where privateLayout = ? and logoId = ?.
`LayoutSetVersion`	`create(long layoutSetVersionId)` Creates a new layout set version with the primary key.
`LayoutSetVersion`	`fetchByG_P_First(long groupId, boolean privateLayout, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ? and privateLayout = ?.
`LayoutSetVersion`	`fetchByG_P_Last(long groupId, boolean privateLayout, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ? and privateLayout = ?.
`LayoutSetVersion`	`fetchByG_P_Version(long groupId, boolean privateLayout, int version)` Returns the layout set version where groupId = ? and privateLayout = ? and version = ? or returns `null` if it could not be found.
`LayoutSetVersion`	`fetchByG_P_Version(long groupId, boolean privateLayout, int version, boolean retrieveFromCache)` Returns the layout set version where groupId = ? and privateLayout = ? and version = ? or returns `null` if it could not be found, optionally using the finder cache.
`LayoutSetVersion`	`fetchByGroupId_First(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ?.
`LayoutSetVersion`	`fetchByGroupId_Last(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ?.
`LayoutSetVersion`	`fetchByGroupId_Version_First(long groupId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ? and version = ?.
`LayoutSetVersion`	`fetchByGroupId_Version_Last(long groupId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ? and version = ?.
`LayoutSetVersion`	`fetchByLayoutSetId_First(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetId = ?.
`LayoutSetVersion`	`fetchByLayoutSetId_Last(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetId = ?.
`LayoutSetVersion`	`fetchByLayoutSetId_Version(long layoutSetId, int version)` Returns the layout set version where layoutSetId = ? and version = ? or returns `null` if it could not be found.
`LayoutSetVersion`	`fetchByLayoutSetId_Version(long layoutSetId, int version, boolean retrieveFromCache)` Returns the layout set version where layoutSetId = ? and version = ? or returns `null` if it could not be found, optionally using the finder cache.
`LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_Version_First(java.lang.String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_Version_Last(java.lang.String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`LayoutSetVersion`	`fetchByP_L_First(boolean privateLayout, long logoId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ?.
`LayoutSetVersion`	`fetchByP_L_Last(boolean privateLayout, long logoId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ?.
`LayoutSetVersion`	`fetchByP_L_Version_First(boolean privateLayout, long logoId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
`LayoutSetVersion`	`fetchByP_L_Version_Last(boolean privateLayout, long logoId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
`LayoutSetVersion`	`fetchByPrimaryKey(long layoutSetVersionId)` Returns the layout set version with the primary key or returns `null` if it could not be found.
`java.util.List<LayoutSetVersion>`	`findAll()` Returns all the layout set versions.
`java.util.List<LayoutSetVersion>`	`findAll(int start, int end)` Returns a range of all the layout set versions.
`java.util.List<LayoutSetVersion>`	`findAll(int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions.
`java.util.List<LayoutSetVersion>`	`findAll(int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions.
`LayoutSetVersion`	`findByG_P_First(long groupId, boolean privateLayout, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ? and privateLayout = ?.
`LayoutSetVersion`	`findByG_P_Last(long groupId, boolean privateLayout, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ? and privateLayout = ?.
`LayoutSetVersion[]`	`findByG_P_PrevAndNext(long layoutSetVersionId, long groupId, boolean privateLayout, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where groupId = ? and privateLayout = ?.
`LayoutSetVersion`	`findByG_P_Version(long groupId, boolean privateLayout, int version)` Returns the layout set version where groupId = ? and privateLayout = ? and version = ? or throws a `NoSuchLayoutSetVersionException` if it could not be found.
`java.util.List<LayoutSetVersion>`	`findByG_P(long groupId, boolean privateLayout)` Returns all the layout set versions where groupId = ? and privateLayout = ?.
`java.util.List<LayoutSetVersion>`	`findByG_P(long groupId, boolean privateLayout, int start, int end)` Returns a range of all the layout set versions where groupId = ? and privateLayout = ?.
`java.util.List<LayoutSetVersion>`	`findByG_P(long groupId, boolean privateLayout, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where groupId = ? and privateLayout = ?.
`java.util.List<LayoutSetVersion>`	`findByG_P(long groupId, boolean privateLayout, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where groupId = ? and privateLayout = ?.
`LayoutSetVersion`	`findByGroupId_First(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ?.
`LayoutSetVersion`	`findByGroupId_Last(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ?.
`LayoutSetVersion[]`	`findByGroupId_PrevAndNext(long layoutSetVersionId, long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where groupId = ?.
`LayoutSetVersion`	`findByGroupId_Version_First(long groupId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ? and version = ?.
`LayoutSetVersion`	`findByGroupId_Version_Last(long groupId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ? and version = ?.
`LayoutSetVersion[]`	`findByGroupId_Version_PrevAndNext(long layoutSetVersionId, long groupId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where groupId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId_Version(long groupId, int version)` Returns all the layout set versions where groupId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId_Version(long groupId, int version, int start, int end)` Returns a range of all the layout set versions where groupId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId_Version(long groupId, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where groupId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId_Version(long groupId, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where groupId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId(long groupId)` Returns all the layout set versions where groupId = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId(long groupId, int start, int end)` Returns a range of all the layout set versions where groupId = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId(long groupId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where groupId = ?.
`java.util.List<LayoutSetVersion>`	`findByGroupId(long groupId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where groupId = ?.
`LayoutSetVersion`	`findByLayoutSetId_First(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetId = ?.
`LayoutSetVersion`	`findByLayoutSetId_Last(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetId = ?.
`LayoutSetVersion[]`	`findByLayoutSetId_PrevAndNext(long layoutSetVersionId, long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where layoutSetId = ?.
`LayoutSetVersion`	`findByLayoutSetId_Version(long layoutSetId, int version)` Returns the layout set version where layoutSetId = ? and version = ? or throws a `NoSuchLayoutSetVersionException` if it could not be found.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId)` Returns all the layout set versions where layoutSetId = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId, int start, int end)` Returns a range of all the layout set versions where layoutSetId = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where layoutSetId = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where layoutSetId = ?.
`LayoutSetVersion`	`findByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`LayoutSetVersion`	`findByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`LayoutSetVersion[]`	`findByLayoutSetPrototypeUuid_PrevAndNext(long layoutSetVersionId, java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`LayoutSetVersion`	`findByLayoutSetPrototypeUuid_Version_First(java.lang.String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`LayoutSetVersion`	`findByLayoutSetPrototypeUuid_Version_Last(java.lang.String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`LayoutSetVersion[]`	`findByLayoutSetPrototypeUuid_Version_PrevAndNext(long layoutSetVersionId, java.lang.String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid, int version)` Returns all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid, int version, int start, int end)` Returns a range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)` Returns all the layout set versions where layoutSetPrototypeUuid = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid, int start, int end)` Returns a range of all the layout set versions where layoutSetPrototypeUuid = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ?.
`java.util.List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ?.
`LayoutSetVersion`	`findByP_L_First(boolean privateLayout, long logoId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ?.
`LayoutSetVersion`	`findByP_L_Last(boolean privateLayout, long logoId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ?.
`LayoutSetVersion[]`	`findByP_L_PrevAndNext(long layoutSetVersionId, boolean privateLayout, long logoId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where privateLayout = ? and logoId = ?.
`LayoutSetVersion`	`findByP_L_Version_First(boolean privateLayout, long logoId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
`LayoutSetVersion`	`findByP_L_Version_Last(boolean privateLayout, long logoId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
`LayoutSetVersion[]`	`findByP_L_Version_PrevAndNext(long layoutSetVersionId, boolean privateLayout, long logoId, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L_Version(boolean privateLayout, long logoId, int version)` Returns all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L_Version(boolean privateLayout, long logoId, int version, int start, int end)` Returns a range of all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L_Version(boolean privateLayout, long logoId, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L_Version(boolean privateLayout, long logoId, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L(boolean privateLayout, long logoId)` Returns all the layout set versions where privateLayout = ? and logoId = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L(boolean privateLayout, long logoId, int start, int end)` Returns a range of all the layout set versions where privateLayout = ? and logoId = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L(boolean privateLayout, long logoId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ?.
`java.util.List<LayoutSetVersion>`	`findByP_L(boolean privateLayout, long logoId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ?.
`LayoutSetVersion`	`findByPrimaryKey(long layoutSetVersionId)` Returns the layout set version with the primary key or throws a `NoSuchLayoutSetVersionException` if it could not be found.
`LayoutSetVersion`	`remove(long layoutSetVersionId)` Removes the layout set version with the primary key from the database.
`void`	`removeAll()` Removes all the layout set versions from the database.
`LayoutSetVersion`	`removeByG_P_Version(long groupId, boolean privateLayout, int version)` Removes the layout set version where groupId = ? and privateLayout = ? and version = ? from the database.
`void`	`removeByG_P(long groupId, boolean privateLayout)` Removes all the layout set versions where groupId = ? and privateLayout = ? from the database.
`void`	`removeByGroupId_Version(long groupId, int version)` Removes all the layout set versions where groupId = ? and version = ? from the database.
`void`	`removeByGroupId(long groupId)` Removes all the layout set versions where groupId = ? from the database.
`LayoutSetVersion`	`removeByLayoutSetId_Version(long layoutSetId, int version)` Removes the layout set version where layoutSetId = ? and version = ? from the database.
`void`	`removeByLayoutSetId(long layoutSetId)` Removes all the layout set versions where layoutSetId = ? from the database.
`void`	`removeByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid, int version)` Removes all the layout set versions where layoutSetPrototypeUuid = ? and version = ? from the database.
`void`	`removeByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)` Removes all the layout set versions where layoutSetPrototypeUuid = ? from the database.
`void`	`removeByP_L_Version(boolean privateLayout, long logoId, int version)` Removes all the layout set versions where privateLayout = ? and logoId = ? and version = ? from the database.
`void`	`removeByP_L(boolean privateLayout, long logoId)` Removes all the layout set versions where privateLayout = ? and logoId = ? from the database.
`LayoutSetVersion`	`updateImpl(LayoutSetVersion layoutSetVersion)`

Methods inherited from interface com.liferay.portal.kernel.service.persistence.BasePersistence
clearCache, clearCache, clearCache, closeSession, countWithDynamicQuery, countWithDynamicQuery, fetchByPrimaryKey, fetchByPrimaryKeys, findByPrimaryKey, findWithDynamicQuery, findWithDynamicQuery, findWithDynamicQuery, flush, getBadColumnNames, getCurrentSession, getDataSource, getListeners, getModelClass, openSession, processException, registerListener, remove, remove, setDataSource, unregisterListener, update, update

- Method Detail
  - findByLayoutSetId
```
java.util.List<LayoutSetVersion> findByLayoutSetId(long layoutSetId)
```
    Returns all the layout set versions where layoutSetId = ?.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    Returns:
    
    the matching layout set versions
  - findByLayoutSetId
```
java.util.List<LayoutSetVersion> findByLayoutSetId(long layoutSetId,
                                                   int start,
                                                   int end)
```
    Returns a range of all the layout set versions where layoutSetId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByLayoutSetId
```
java.util.List<LayoutSetVersion> findByLayoutSetId(long layoutSetId,
                                                   int start,
                                                   int end,
                                                   OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where layoutSetId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetId
```
java.util.List<LayoutSetVersion> findByLayoutSetId(long layoutSetId,
                                                   int start,
                                                   int end,
                                                   OrderByComparator<LayoutSetVersion> orderByComparator,
                                                   boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where layoutSetId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetId_First
```
LayoutSetVersion findByLayoutSetId_First(long layoutSetId,
                                         OrderByComparator<LayoutSetVersion> orderByComparator)
                                  throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where layoutSetId = ?.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByLayoutSetId_First
```
LayoutSetVersion fetchByLayoutSetId_First(long layoutSetId,
                                          OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where layoutSetId = ?.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByLayoutSetId_Last
```
LayoutSetVersion findByLayoutSetId_Last(long layoutSetId,
                                        OrderByComparator<LayoutSetVersion> orderByComparator)
                                 throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where layoutSetId = ?.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByLayoutSetId_Last
```
LayoutSetVersion fetchByLayoutSetId_Last(long layoutSetId,
                                         OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where layoutSetId = ?.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByLayoutSetId_PrevAndNext
```
LayoutSetVersion[] findByLayoutSetId_PrevAndNext(long layoutSetVersionId,
                                                 long layoutSetId,
                                                 OrderByComparator<LayoutSetVersion> orderByComparator)
                                          throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where layoutSetId = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    layoutSetId - the layout set ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByLayoutSetId
```
void removeByLayoutSetId(long layoutSetId)
```
    Removes all the layout set versions where layoutSetId = ? from the database.
    
    Parameters:
    
    layoutSetId - the layout set ID
  - countByLayoutSetId
```
int countByLayoutSetId(long layoutSetId)
```
    Returns the number of layout set versions where layoutSetId = ?.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    Returns:
    
    the number of matching layout set versions
  - findByLayoutSetId_Version
```
LayoutSetVersion findByLayoutSetId_Version(long layoutSetId,
                                           int version)
                                    throws NoSuchLayoutSetVersionException
```
    Returns the layout set version where layoutSetId = ? and version = ? or throws a NoSuchLayoutSetVersionException if it could not be found.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    version - the version
    
    Returns:
    
    the matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByLayoutSetId_Version
```
LayoutSetVersion fetchByLayoutSetId_Version(long layoutSetId,
                                            int version)
```
    Returns the layout set version where layoutSetId = ? and version = ? or returns null if it could not be found. Uses the finder cache.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    version - the version
    
    Returns:
    
    the matching layout set version, or null if a matching layout set version could not be found
  - fetchByLayoutSetId_Version
```
LayoutSetVersion fetchByLayoutSetId_Version(long layoutSetId,
                                            int version,
                                            boolean retrieveFromCache)
```
    Returns the layout set version where layoutSetId = ? and version = ? or returns null if it could not be found, optionally using the finder cache.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    version - the version
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the matching layout set version, or null if a matching layout set version could not be found
  - removeByLayoutSetId_Version
```
LayoutSetVersion removeByLayoutSetId_Version(long layoutSetId,
                                             int version)
                                      throws NoSuchLayoutSetVersionException
```
    Removes the layout set version where layoutSetId = ? and version = ? from the database.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    version - the version
    
    Returns:
    
    the layout set version that was removed
    
    Throws:
    
    NoSuchLayoutSetVersionException
  - countByLayoutSetId_Version
```
int countByLayoutSetId_Version(long layoutSetId,
                               int version)
```
    Returns the number of layout set versions where layoutSetId = ? and version = ?.
    
    Parameters:
    
    layoutSetId - the layout set ID
    
    version - the version
    
    Returns:
    
    the number of matching layout set versions
  - findByGroupId
```
java.util.List<LayoutSetVersion> findByGroupId(long groupId)
```
    Returns all the layout set versions where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    Returns:
    
    the matching layout set versions
  - findByGroupId
```
java.util.List<LayoutSetVersion> findByGroupId(long groupId,
                                               int start,
                                               int end)
```
    Returns a range of all the layout set versions where groupId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByGroupId
```
java.util.List<LayoutSetVersion> findByGroupId(long groupId,
                                               int start,
                                               int end,
                                               OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where groupId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByGroupId
```
java.util.List<LayoutSetVersion> findByGroupId(long groupId,
                                               int start,
                                               int end,
                                               OrderByComparator<LayoutSetVersion> orderByComparator,
                                               boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where groupId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByGroupId_First
```
LayoutSetVersion findByGroupId_First(long groupId,
                                     OrderByComparator<LayoutSetVersion> orderByComparator)
                              throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByGroupId_First
```
LayoutSetVersion fetchByGroupId_First(long groupId,
                                      OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByGroupId_Last
```
LayoutSetVersion findByGroupId_Last(long groupId,
                                    OrderByComparator<LayoutSetVersion> orderByComparator)
                             throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByGroupId_Last
```
LayoutSetVersion fetchByGroupId_Last(long groupId,
                                     OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByGroupId_PrevAndNext
```
LayoutSetVersion[] findByGroupId_PrevAndNext(long layoutSetVersionId,
                                             long groupId,
                                             OrderByComparator<LayoutSetVersion> orderByComparator)
                                      throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where groupId = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByGroupId
```
void removeByGroupId(long groupId)
```
    Removes all the layout set versions where groupId = ? from the database.
    
    Parameters:
    
    groupId - the group ID
  - countByGroupId
```
int countByGroupId(long groupId)
```
    Returns the number of layout set versions where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    Returns:
    
    the number of matching layout set versions
  - findByGroupId_Version
```
java.util.List<LayoutSetVersion> findByGroupId_Version(long groupId,
                                                       int version)
```
    Returns all the layout set versions where groupId = ? and version = ?.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    Returns:
    
    the matching layout set versions
  - findByGroupId_Version
```
java.util.List<LayoutSetVersion> findByGroupId_Version(long groupId,
                                                       int version,
                                                       int start,
                                                       int end)
```
    Returns a range of all the layout set versions where groupId = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByGroupId_Version
```
java.util.List<LayoutSetVersion> findByGroupId_Version(long groupId,
                                                       int version,
                                                       int start,
                                                       int end,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where groupId = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByGroupId_Version
```
java.util.List<LayoutSetVersion> findByGroupId_Version(long groupId,
                                                       int version,
                                                       int start,
                                                       int end,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator,
                                                       boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where groupId = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByGroupId_Version_First
```
LayoutSetVersion findByGroupId_Version_First(long groupId,
                                             int version,
                                             OrderByComparator<LayoutSetVersion> orderByComparator)
                                      throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where groupId = ? and version = ?.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByGroupId_Version_First
```
LayoutSetVersion fetchByGroupId_Version_First(long groupId,
                                              int version,
                                              OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where groupId = ? and version = ?.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByGroupId_Version_Last
```
LayoutSetVersion findByGroupId_Version_Last(long groupId,
                                            int version,
                                            OrderByComparator<LayoutSetVersion> orderByComparator)
                                     throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where groupId = ? and version = ?.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByGroupId_Version_Last
```
LayoutSetVersion fetchByGroupId_Version_Last(long groupId,
                                             int version,
                                             OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where groupId = ? and version = ?.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByGroupId_Version_PrevAndNext
```
LayoutSetVersion[] findByGroupId_Version_PrevAndNext(long layoutSetVersionId,
                                                     long groupId,
                                                     int version,
                                                     OrderByComparator<LayoutSetVersion> orderByComparator)
                                              throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where groupId = ? and version = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    groupId - the group ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByGroupId_Version
```
void removeByGroupId_Version(long groupId,
                             int version)
```
    Removes all the layout set versions where groupId = ? and version = ? from the database.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
  - countByGroupId_Version
```
int countByGroupId_Version(long groupId,
                           int version)
```
    Returns the number of layout set versions where groupId = ? and version = ?.
    
    Parameters:
    
    groupId - the group ID
    
    version - the version
    
    Returns:
    
    the number of matching layout set versions
  - findByLayoutSetPrototypeUuid
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)
```
    Returns all the layout set versions where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    Returns:
    
    the matching layout set versions
  - findByLayoutSetPrototypeUuid
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid,
                                                              int start,
                                                              int end)
```
    Returns a range of all the layout set versions where layoutSetPrototypeUuid = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByLayoutSetPrototypeUuid
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid,
                                                              int start,
                                                              int end,
                                                              OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetPrototypeUuid
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid,
                                                              int start,
                                                              int end,
                                                              OrderByComparator<LayoutSetVersion> orderByComparator,
                                                              boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetPrototypeUuid_First
```
LayoutSetVersion findByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid,
                                                    OrderByComparator<LayoutSetVersion> orderByComparator)
                                             throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByLayoutSetPrototypeUuid_First
```
LayoutSetVersion fetchByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid,
                                                     OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByLayoutSetPrototypeUuid_Last
```
LayoutSetVersion findByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid,
                                                   OrderByComparator<LayoutSetVersion> orderByComparator)
                                            throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByLayoutSetPrototypeUuid_Last
```
LayoutSetVersion fetchByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid,
                                                    OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByLayoutSetPrototypeUuid_PrevAndNext
```
LayoutSetVersion[] findByLayoutSetPrototypeUuid_PrevAndNext(long layoutSetVersionId,
                                                            java.lang.String layoutSetPrototypeUuid,
                                                            OrderByComparator<LayoutSetVersion> orderByComparator)
                                                     throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByLayoutSetPrototypeUuid
```
void removeByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)
```
    Removes all the layout set versions where layoutSetPrototypeUuid = ? from the database.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
  - countByLayoutSetPrototypeUuid
```
int countByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)
```
    Returns the number of layout set versions where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    Returns:
    
    the number of matching layout set versions
  - findByLayoutSetPrototypeUuid_Version
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid,
                                                                      int version)
```
    Returns all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    Returns:
    
    the matching layout set versions
  - findByLayoutSetPrototypeUuid_Version
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid,
                                                                      int version,
                                                                      int start,
                                                                      int end)
```
    Returns a range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByLayoutSetPrototypeUuid_Version
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid,
                                                                      int version,
                                                                      int start,
                                                                      int end,
                                                                      OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetPrototypeUuid_Version
```
java.util.List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid,
                                                                      int version,
                                                                      int start,
                                                                      int end,
                                                                      OrderByComparator<LayoutSetVersion> orderByComparator,
                                                                      boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetPrototypeUuid_Version_First
```
LayoutSetVersion findByLayoutSetPrototypeUuid_Version_First(java.lang.String layoutSetPrototypeUuid,
                                                            int version,
                                                            OrderByComparator<LayoutSetVersion> orderByComparator)
                                                     throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByLayoutSetPrototypeUuid_Version_First
```
LayoutSetVersion fetchByLayoutSetPrototypeUuid_Version_First(java.lang.String layoutSetPrototypeUuid,
                                                             int version,
                                                             OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByLayoutSetPrototypeUuid_Version_Last
```
LayoutSetVersion findByLayoutSetPrototypeUuid_Version_Last(java.lang.String layoutSetPrototypeUuid,
                                                           int version,
                                                           OrderByComparator<LayoutSetVersion> orderByComparator)
                                                    throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByLayoutSetPrototypeUuid_Version_Last
```
LayoutSetVersion fetchByLayoutSetPrototypeUuid_Version_Last(java.lang.String layoutSetPrototypeUuid,
                                                            int version,
                                                            OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByLayoutSetPrototypeUuid_Version_PrevAndNext
```
LayoutSetVersion[] findByLayoutSetPrototypeUuid_Version_PrevAndNext(long layoutSetVersionId,
                                                                    java.lang.String layoutSetPrototypeUuid,
                                                                    int version,
                                                                    OrderByComparator<LayoutSetVersion> orderByComparator)
                                                             throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByLayoutSetPrototypeUuid_Version
```
void removeByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid,
                                            int version)
```
    Removes all the layout set versions where layoutSetPrototypeUuid = ? and version = ? from the database.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
  - countByLayoutSetPrototypeUuid_Version
```
int countByLayoutSetPrototypeUuid_Version(java.lang.String layoutSetPrototypeUuid,
                                          int version)
```
    Returns the number of layout set versions where layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    Returns:
    
    the number of matching layout set versions
  - findByG_P
```
java.util.List<LayoutSetVersion> findByG_P(long groupId,
                                           boolean privateLayout)
```
    Returns all the layout set versions where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    Returns:
    
    the matching layout set versions
  - findByG_P
```
java.util.List<LayoutSetVersion> findByG_P(long groupId,
                                           boolean privateLayout,
                                           int start,
                                           int end)
```
    Returns a range of all the layout set versions where groupId = ? and privateLayout = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByG_P
```
java.util.List<LayoutSetVersion> findByG_P(long groupId,
                                           boolean privateLayout,
                                           int start,
                                           int end,
                                           OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where groupId = ? and privateLayout = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByG_P
```
java.util.List<LayoutSetVersion> findByG_P(long groupId,
                                           boolean privateLayout,
                                           int start,
                                           int end,
                                           OrderByComparator<LayoutSetVersion> orderByComparator,
                                           boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where groupId = ? and privateLayout = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByG_P_First
```
LayoutSetVersion findByG_P_First(long groupId,
                                 boolean privateLayout,
                                 OrderByComparator<LayoutSetVersion> orderByComparator)
                          throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByG_P_First
```
LayoutSetVersion fetchByG_P_First(long groupId,
                                  boolean privateLayout,
                                  OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByG_P_Last
```
LayoutSetVersion findByG_P_Last(long groupId,
                                boolean privateLayout,
                                OrderByComparator<LayoutSetVersion> orderByComparator)
                         throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByG_P_Last
```
LayoutSetVersion fetchByG_P_Last(long groupId,
                                 boolean privateLayout,
                                 OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByG_P_PrevAndNext
```
LayoutSetVersion[] findByG_P_PrevAndNext(long layoutSetVersionId,
                                         long groupId,
                                         boolean privateLayout,
                                         OrderByComparator<LayoutSetVersion> orderByComparator)
                                  throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByG_P
```
void removeByG_P(long groupId,
                 boolean privateLayout)
```
    Removes all the layout set versions where groupId = ? and privateLayout = ? from the database.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
  - countByG_P
```
int countByG_P(long groupId,
               boolean privateLayout)
```
    Returns the number of layout set versions where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    Returns:
    
    the number of matching layout set versions
  - findByG_P_Version
```
LayoutSetVersion findByG_P_Version(long groupId,
                                   boolean privateLayout,
                                   int version)
                            throws NoSuchLayoutSetVersionException
```
    Returns the layout set version where groupId = ? and privateLayout = ? and version = ? or throws a NoSuchLayoutSetVersionException if it could not be found.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    version - the version
    
    Returns:
    
    the matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByG_P_Version
```
LayoutSetVersion fetchByG_P_Version(long groupId,
                                    boolean privateLayout,
                                    int version)
```
    Returns the layout set version where groupId = ? and privateLayout = ? and version = ? or returns null if it could not be found. Uses the finder cache.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    version - the version
    
    Returns:
    
    the matching layout set version, or null if a matching layout set version could not be found
  - fetchByG_P_Version
```
LayoutSetVersion fetchByG_P_Version(long groupId,
                                    boolean privateLayout,
                                    int version,
                                    boolean retrieveFromCache)
```
    Returns the layout set version where groupId = ? and privateLayout = ? and version = ? or returns null if it could not be found, optionally using the finder cache.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    version - the version
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the matching layout set version, or null if a matching layout set version could not be found
  - removeByG_P_Version
```
LayoutSetVersion removeByG_P_Version(long groupId,
                                     boolean privateLayout,
                                     int version)
                              throws NoSuchLayoutSetVersionException
```
    Removes the layout set version where groupId = ? and privateLayout = ? and version = ? from the database.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    version - the version
    
    Returns:
    
    the layout set version that was removed
    
    Throws:
    
    NoSuchLayoutSetVersionException
  - countByG_P_Version
```
int countByG_P_Version(long groupId,
                       boolean privateLayout,
                       int version)
```
    Returns the number of layout set versions where groupId = ? and privateLayout = ? and version = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    version - the version
    
    Returns:
    
    the number of matching layout set versions
  - findByP_L
```
java.util.List<LayoutSetVersion> findByP_L(boolean privateLayout,
                                           long logoId)
```
    Returns all the layout set versions where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    Returns:
    
    the matching layout set versions
  - findByP_L
```
java.util.List<LayoutSetVersion> findByP_L(boolean privateLayout,
                                           long logoId,
                                           int start,
                                           int end)
```
    Returns a range of all the layout set versions where privateLayout = ? and logoId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByP_L
```
java.util.List<LayoutSetVersion> findByP_L(boolean privateLayout,
                                           long logoId,
                                           int start,
                                           int end,
                                           OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByP_L
```
java.util.List<LayoutSetVersion> findByP_L(boolean privateLayout,
                                           long logoId,
                                           int start,
                                           int end,
                                           OrderByComparator<LayoutSetVersion> orderByComparator,
                                           boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByP_L_First
```
LayoutSetVersion findByP_L_First(boolean privateLayout,
                                 long logoId,
                                 OrderByComparator<LayoutSetVersion> orderByComparator)
                          throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByP_L_First
```
LayoutSetVersion fetchByP_L_First(boolean privateLayout,
                                  long logoId,
                                  OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByP_L_Last
```
LayoutSetVersion findByP_L_Last(boolean privateLayout,
                                long logoId,
                                OrderByComparator<LayoutSetVersion> orderByComparator)
                         throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByP_L_Last
```
LayoutSetVersion fetchByP_L_Last(boolean privateLayout,
                                 long logoId,
                                 OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByP_L_PrevAndNext
```
LayoutSetVersion[] findByP_L_PrevAndNext(long layoutSetVersionId,
                                         boolean privateLayout,
                                         long logoId,
                                         OrderByComparator<LayoutSetVersion> orderByComparator)
                                  throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByP_L
```
void removeByP_L(boolean privateLayout,
                 long logoId)
```
    Removes all the layout set versions where privateLayout = ? and logoId = ? from the database.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
  - countByP_L
```
int countByP_L(boolean privateLayout,
               long logoId)
```
    Returns the number of layout set versions where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    Returns:
    
    the number of matching layout set versions
  - findByP_L_Version
```
java.util.List<LayoutSetVersion> findByP_L_Version(boolean privateLayout,
                                                   long logoId,
                                                   int version)
```
    Returns all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    Returns:
    
    the matching layout set versions
  - findByP_L_Version
```
java.util.List<LayoutSetVersion> findByP_L_Version(boolean privateLayout,
                                                   long logoId,
                                                   int version,
                                                   int start,
                                                   int end)
```
    Returns a range of all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of matching layout set versions
  - findByP_L_Version
```
java.util.List<LayoutSetVersion> findByP_L_Version(boolean privateLayout,
                                                   long logoId,
                                                   int version,
                                                   int start,
                                                   int end,
                                                   OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByP_L_Version
```
java.util.List<LayoutSetVersion> findByP_L_Version(boolean privateLayout,
                                                   long logoId,
                                                   int version,
                                                   int start,
                                                   int end,
                                                   OrderByComparator<LayoutSetVersion> orderByComparator,
                                                   boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByP_L_Version_First
```
LayoutSetVersion findByP_L_Version_First(boolean privateLayout,
                                         long logoId,
                                         int version,
                                         OrderByComparator<LayoutSetVersion> orderByComparator)
                                  throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByP_L_Version_First
```
LayoutSetVersion fetchByP_L_Version_First(boolean privateLayout,
                                          long logoId,
                                          int version,
                                          OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set version, or null if a matching layout set version could not be found
  - findByP_L_Version_Last
```
LayoutSetVersion findByP_L_Version_Last(boolean privateLayout,
                                        long logoId,
                                        int version,
                                        OrderByComparator<LayoutSetVersion> orderByComparator)
                                 throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a matching layout set version could not be found
  - fetchByP_L_Version_Last
```
LayoutSetVersion fetchByP_L_Version_Last(boolean privateLayout,
                                         long logoId,
                                         int version,
                                         OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set version, or null if a matching layout set version could not be found
  - findByP_L_Version_PrevAndNext
```
LayoutSetVersion[] findByP_L_Version_PrevAndNext(long layoutSetVersionId,
                                                 boolean privateLayout,
                                                 long logoId,
                                                 int version,
                                                 OrderByComparator<LayoutSetVersion> orderByComparator)
                                          throws NoSuchLayoutSetVersionException
```
    Returns the layout set versions before and after the current layout set version in the ordered set where privateLayout = ? and logoId = ? and version = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - removeByP_L_Version
```
void removeByP_L_Version(boolean privateLayout,
                         long logoId,
                         int version)
```
    Removes all the layout set versions where privateLayout = ? and logoId = ? and version = ? from the database.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
  - countByP_L_Version
```
int countByP_L_Version(boolean privateLayout,
                       long logoId,
                       int version)
```
    Returns the number of layout set versions where privateLayout = ? and logoId = ? and version = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    version - the version
    
    Returns:
    
    the number of matching layout set versions
  - cacheResult
```
void cacheResult(LayoutSetVersion layoutSetVersion)
```
    Caches the layout set version in the entity cache if it is enabled.
    
    Parameters:
    
    layoutSetVersion - the layout set version
  - cacheResult
```
void cacheResult(java.util.List<LayoutSetVersion> layoutSetVersions)
```
    Caches the layout set versions in the entity cache if it is enabled.
    
    Parameters:
    
    layoutSetVersions - the layout set versions
  - create
```
LayoutSetVersion create(long layoutSetVersionId)
```
    Creates a new layout set version with the primary key. Does not add the layout set version to the database.
    
    Parameters:
    
    layoutSetVersionId - the primary key for the new layout set version
    
    Returns:
    
    the new layout set version
  - remove
```
LayoutSetVersion remove(long layoutSetVersionId)
                 throws NoSuchLayoutSetVersionException
```
    Removes the layout set version with the primary key from the database. Also notifies the appropriate model listeners.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the layout set version
    
    Returns:
    
    the layout set version that was removed
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - updateImpl
```
LayoutSetVersion updateImpl(LayoutSetVersion layoutSetVersion)
```
  - findByPrimaryKey
```
LayoutSetVersion findByPrimaryKey(long layoutSetVersionId)
                           throws NoSuchLayoutSetVersionException
```
    Returns the layout set version with the primary key or throws a NoSuchLayoutSetVersionException if it could not be found.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the layout set version
    
    Returns:
    
    the layout set version
    
    Throws:
    
    NoSuchLayoutSetVersionException - if a layout set version with the primary key could not be found
  - fetchByPrimaryKey
```
LayoutSetVersion fetchByPrimaryKey(long layoutSetVersionId)
```
    Returns the layout set version with the primary key or returns null if it could not be found.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the layout set version
    
    Returns:
    
    the layout set version, or null if a layout set version with the primary key could not be found
  - findAll
```
java.util.List<LayoutSetVersion> findAll()
```
    Returns all the layout set versions.
    
    Returns:
    
    the layout set versions
  - findAll
```
java.util.List<LayoutSetVersion> findAll(int start,
                                         int end)
```
    Returns a range of all the layout set versions.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    Returns:
    
    the range of layout set versions
  - findAll
```
java.util.List<LayoutSetVersion> findAll(int start,
                                         int end,
                                         OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of layout set versions
  - findAll
```
java.util.List<LayoutSetVersion> findAll(int start,
                                         int end,
                                         OrderByComparator<LayoutSetVersion> orderByComparator,
                                         boolean retrieveFromCache)
```
    Returns an ordered range of all the layout set versions.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetVersionModelImpl. If both orderByComparator and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
    
    Parameters:
    
    start - the lower bound of the range of layout set versions
    
    end - the upper bound of the range of layout set versions (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of layout set versions
  - removeAll
```
void removeAll()
```
    Removes all the layout set versions from the database.
  - countAll
```
int countAll()
```
    Returns the number of layout set versions.
    
    Returns:
    
    the number of layout set versions

Interface LayoutSetVersionPersistence

Method Summary

Methods inherited from interface com.liferay.portal.kernel.service.persistence.BasePersistence

Method Detail

findByLayoutSetId

findByLayoutSetId

findByLayoutSetId

findByLayoutSetId

findByLayoutSetId_First

fetchByLayoutSetId_First

findByLayoutSetId_Last

fetchByLayoutSetId_Last

findByLayoutSetId_PrevAndNext

removeByLayoutSetId

countByLayoutSetId

findByLayoutSetId_Version

fetchByLayoutSetId_Version

fetchByLayoutSetId_Version

removeByLayoutSetId_Version

countByLayoutSetId_Version

findByGroupId

findByGroupId

findByGroupId

findByGroupId

findByGroupId_First

fetchByGroupId_First

findByGroupId_Last

fetchByGroupId_Last

findByGroupId_PrevAndNext

removeByGroupId

countByGroupId

findByGroupId_Version

findByGroupId_Version

findByGroupId_Version

findByGroupId_Version

findByGroupId_Version_First

fetchByGroupId_Version_First

findByGroupId_Version_Last

fetchByGroupId_Version_Last

findByGroupId_Version_PrevAndNext

removeByGroupId_Version

countByGroupId_Version

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid_First

fetchByLayoutSetPrototypeUuid_First

findByLayoutSetPrototypeUuid_Last

fetchByLayoutSetPrototypeUuid_Last

findByLayoutSetPrototypeUuid_PrevAndNext

removeByLayoutSetPrototypeUuid

countByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid_Version

findByLayoutSetPrototypeUuid_Version

findByLayoutSetPrototypeUuid_Version

findByLayoutSetPrototypeUuid_Version

findByLayoutSetPrototypeUuid_Version_First

fetchByLayoutSetPrototypeUuid_Version_First

findByLayoutSetPrototypeUuid_Version_Last

fetchByLayoutSetPrototypeUuid_Version_Last

findByLayoutSetPrototypeUuid_Version_PrevAndNext

removeByLayoutSetPrototypeUuid_Version

countByLayoutSetPrototypeUuid_Version

findByG_P

findByG_P

findByG_P

findByG_P

findByG_P_First

fetchByG_P_First

findByG_P_Last

fetchByG_P_Last

findByG_P_PrevAndNext

removeByG_P

countByG_P

findByG_P_Version

fetchByG_P_Version

fetchByG_P_Version

removeByG_P_Version

countByG_P_Version