LayoutSetVersionUtil (Liferay 7.2.10 portal-kernel API)

Object
- com.liferay.portal.kernel.service.persistence.LayoutSetVersionUtil

```
public class LayoutSetVersionUtil
extends Object
```
The persistence utility for the layout set version service. This utility wraps com.liferay.portal.service.persistence.impl.LayoutSetVersionPersistenceImpl and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
Caching information and settings can be found in portal.properties

Author:

Brian Wing Shun Chan

See Also:

LayoutSetVersionPersistence

{$generated.description}

Constructor Summary

Constructors
Constructor and Description

LayoutSetVersionUtil()

Constructors
Constructor and Description
`LayoutSetVersionUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`cacheResult(LayoutSetVersion layoutSetVersion)` Caches the layout set version in the entity cache if it is enabled.
`static void`	`cacheResult(List<LayoutSetVersion> layoutSetVersions)` Caches the layout set versions in the entity cache if it is enabled.
`static void`	`clearCache()`
`static void`	`clearCache(LayoutSetVersion layoutSetVersion)`
`static int`	`countAll()` Returns the number of layout set versions.
`static int`	`countByC_L_Version(long companyId, String layoutSetPrototypeUuid, int version)` Returns the number of layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static int`	`countByC_L(long companyId, String layoutSetPrototypeUuid)` Returns the number of layout set versions where companyId = ? and layoutSetPrototypeUuid = ?.
`static int`	`countByG_P_Version(long groupId, boolean privateLayout, int version)` Returns the number of layout set versions where groupId = ? and privateLayout = ? and version = ?.
`static int`	`countByG_P(long groupId, boolean privateLayout)` Returns the number of layout set versions where groupId = ? and privateLayout = ?.
`static int`	`countByGroupId_Version(long groupId, int version)` Returns the number of layout set versions where groupId = ? and version = ?.
`static int`	`countByGroupId(long groupId)` Returns the number of layout set versions where groupId = ?.
`static int`	`countByLayoutSetId_Version(long layoutSetId, int version)` Returns the number of layout set versions where layoutSetId = ? and version = ?.
`static int`	`countByLayoutSetId(long layoutSetId)` Returns the number of layout set versions where layoutSetId = ?.
`static int`	`countByLayoutSetPrototypeUuid_Version(String layoutSetPrototypeUuid, int version)` Returns the number of layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`static int`	`countByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid)` Returns the number of layout set versions where layoutSetPrototypeUuid = ?.
`static int`	`countByP_L_Version(boolean privateLayout, long logoId, int version)` Returns the number of layout set versions where privateLayout = ? and logoId = ? and version = ?.
`static int`	`countByP_L(boolean privateLayout, long logoId)` Returns the number of layout set versions where privateLayout = ? and logoId = ?.
`static long`	`countWithDynamicQuery(DynamicQuery dynamicQuery)`
`static LayoutSetVersion`	`create(long layoutSetVersionId)` Creates a new layout set version with the primary key.
`static LayoutSetVersion`	`fetchByC_L_First(long companyId, String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`fetchByC_L_Last(long companyId, String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`fetchByC_L_Version_First(long companyId, String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static LayoutSetVersion`	`fetchByC_L_Version_Last(long companyId, String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static 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 = ?.
`static 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 = ?.
`static 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.
`static LayoutSetVersion`	`fetchByG_P_Version(long groupId, boolean privateLayout, int version, boolean useFinderCache)` 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.
`static LayoutSetVersion`	`fetchByGroupId_First(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ?.
`static LayoutSetVersion`	`fetchByGroupId_Last(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ?.
`static 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 = ?.
`static 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 = ?.
`static LayoutSetVersion`	`fetchByLayoutSetId_First(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetId = ?.
`static LayoutSetVersion`	`fetchByLayoutSetId_Last(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetId = ?.
`static 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.
`static LayoutSetVersion`	`fetchByLayoutSetId_Version(long layoutSetId, int version, boolean useFinderCache)` Returns the layout set version where layoutSetId = ? and version = ? or returns `null` if it could not be found, optionally using the finder cache.
`static LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_First(String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_Last(String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_Version_First(String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`static LayoutSetVersion`	`fetchByLayoutSetPrototypeUuid_Version_Last(String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static LayoutSetVersion`	`fetchByPrimaryKey(long layoutSetVersionId)` Returns the layout set version with the primary key or returns `null` if it could not be found.
`static Map<Serializable,LayoutSetVersion>`	`fetchByPrimaryKeys(Set<Serializable> primaryKeys)`
`static List<LayoutSetVersion>`	`findAll()` Returns all the layout set versions.
`static List<LayoutSetVersion>`	`findAll(int start, int end)` Returns a range of all the layout set versions.
`static List<LayoutSetVersion>`	`findAll(int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions.
`static List<LayoutSetVersion>`	`findAll(int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions.
`static LayoutSetVersion`	`findByC_L_First(long companyId, String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`findByC_L_Last(long companyId, String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
`static LayoutSetVersion[]`	`findByC_L_PrevAndNext(long layoutSetVersionId, long companyId, String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`findByC_L_Version_First(long companyId, String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static LayoutSetVersion`	`findByC_L_Version_Last(long companyId, String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static LayoutSetVersion[]`	`findByC_L_Version_PrevAndNext(long layoutSetVersionId, long companyId, 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 companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByC_L_Version(long companyId, String layoutSetPrototypeUuid, int version)` Returns all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByC_L_Version(long companyId, String layoutSetPrototypeUuid, int version, int start, int end)` Returns a range of all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByC_L_Version(long companyId, String layoutSetPrototypeUuid, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByC_L_Version(long companyId, String layoutSetPrototypeUuid, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByC_L(long companyId, String layoutSetPrototypeUuid)` Returns all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ?.
`static List<LayoutSetVersion>`	`findByC_L(long companyId, String layoutSetPrototypeUuid, int start, int end)` Returns a range of all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ?.
`static List<LayoutSetVersion>`	`findByC_L(long companyId, String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ?.
`static List<LayoutSetVersion>`	`findByC_L(long companyId, String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static 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.
`static List<LayoutSetVersion>`	`findByG_P(long groupId, boolean privateLayout)` Returns all the layout set versions where groupId = ? and privateLayout = ?.
`static 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 = ?.
`static 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 = ?.
`static List<LayoutSetVersion>`	`findByG_P(long groupId, boolean privateLayout, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where groupId = ? and privateLayout = ?.
`static LayoutSetVersion`	`findByGroupId_First(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where groupId = ?.
`static LayoutSetVersion`	`findByGroupId_Last(long groupId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where groupId = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static List<LayoutSetVersion>`	`findByGroupId_Version(long groupId, int version)` Returns all the layout set versions where groupId = ? and version = ?.
`static 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 = ?.
`static 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 = ?.
`static List<LayoutSetVersion>`	`findByGroupId_Version(long groupId, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where groupId = ? and version = ?.
`static List<LayoutSetVersion>`	`findByGroupId(long groupId)` Returns all the layout set versions where groupId = ?.
`static List<LayoutSetVersion>`	`findByGroupId(long groupId, int start, int end)` Returns a range of all the layout set versions where groupId = ?.
`static List<LayoutSetVersion>`	`findByGroupId(long groupId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where groupId = ?.
`static List<LayoutSetVersion>`	`findByGroupId(long groupId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where groupId = ?.
`static LayoutSetVersion`	`findByLayoutSetId_First(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetId = ?.
`static LayoutSetVersion`	`findByLayoutSetId_Last(long layoutSetId, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetId = ?.
`static 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 = ?.
`static 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.
`static List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId)` Returns all the layout set versions where layoutSetId = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId, int start, int end)` Returns a range of all the layout set versions where layoutSetId = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where layoutSetId = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetId(long layoutSetId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where layoutSetId = ?.
`static LayoutSetVersion`	`findByLayoutSetPrototypeUuid_First(String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`findByLayoutSetPrototypeUuid_Last(String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSetVersion[]`	`findByLayoutSetPrototypeUuid_PrevAndNext(long layoutSetVersionId, String layoutSetPrototypeUuid, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the layout set versions before and after the current layout set version in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSetVersion`	`findByLayoutSetPrototypeUuid_Version_First(String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the first layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`static LayoutSetVersion`	`findByLayoutSetPrototypeUuid_Version_Last(String layoutSetPrototypeUuid, int version, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns the last layout set version in the ordered set where layoutSetPrototypeUuid = ? and version = ?.
`static LayoutSetVersion[]`	`findByLayoutSetPrototypeUuid_Version_PrevAndNext(long layoutSetVersionId, 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 = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(String layoutSetPrototypeUuid, int version)` Returns all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(String layoutSetPrototypeUuid, int version, int start, int end)` Returns a range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(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 = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid_Version(String layoutSetPrototypeUuid, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ? and version = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid)` Returns all the layout set versions where layoutSetPrototypeUuid = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid, int start, int end)` Returns a range of all the layout set versions where layoutSetPrototypeUuid = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)` Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ?.
`static List<LayoutSetVersion>`	`findByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where layoutSetPrototypeUuid = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static 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 = ?.
`static List<LayoutSetVersion>`	`findByP_L_Version(boolean privateLayout, long logoId, int version)` Returns all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
`static 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 = ?.
`static 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 = ?.
`static List<LayoutSetVersion>`	`findByP_L_Version(boolean privateLayout, long logoId, int version, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ? and version = ?.
`static List<LayoutSetVersion>`	`findByP_L(boolean privateLayout, long logoId)` Returns all the layout set versions where privateLayout = ? and logoId = ?.
`static 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 = ?.
`static 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 = ?.
`static List<LayoutSetVersion>`	`findByP_L(boolean privateLayout, long logoId, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator, boolean useFinderCache)` Returns an ordered range of all the layout set versions where privateLayout = ? and logoId = ?.
`static LayoutSetVersion`	`findByPrimaryKey(long layoutSetVersionId)` Returns the layout set version with the primary key or throws a `NoSuchLayoutSetVersionException` if it could not be found.
`static List<LayoutSetVersion>`	`findWithDynamicQuery(DynamicQuery dynamicQuery)`
`static List<LayoutSetVersion>`	`findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end)`
`static List<LayoutSetVersion>`	`findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end, OrderByComparator<LayoutSetVersion> orderByComparator)`
`static LayoutSetVersionPersistence`	`getPersistence()`
`static LayoutSetVersion`	`remove(long layoutSetVersionId)` Removes the layout set version with the primary key from the database.
`static void`	`removeAll()` Removes all the layout set versions from the database.
`static void`	`removeByC_L_Version(long companyId, String layoutSetPrototypeUuid, int version)` Removes all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ? from the database.
`static void`	`removeByC_L(long companyId, String layoutSetPrototypeUuid)` Removes all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? from the database.
`static LayoutSetVersion`	`removeByG_P_Version(long groupId, boolean privateLayout, int version)` Removes the layout set version where groupId = ? and privateLayout = ? and version = ? from the database.
`static void`	`removeByG_P(long groupId, boolean privateLayout)` Removes all the layout set versions where groupId = ? and privateLayout = ? from the database.
`static void`	`removeByGroupId_Version(long groupId, int version)` Removes all the layout set versions where groupId = ? and version = ? from the database.
`static void`	`removeByGroupId(long groupId)` Removes all the layout set versions where groupId = ? from the database.
`static LayoutSetVersion`	`removeByLayoutSetId_Version(long layoutSetId, int version)` Removes the layout set version where layoutSetId = ? and version = ? from the database.
`static void`	`removeByLayoutSetId(long layoutSetId)` Removes all the layout set versions where layoutSetId = ? from the database.
`static void`	`removeByLayoutSetPrototypeUuid_Version(String layoutSetPrototypeUuid, int version)` Removes all the layout set versions where layoutSetPrototypeUuid = ? and version = ? from the database.
`static void`	`removeByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid)` Removes all the layout set versions where layoutSetPrototypeUuid = ? from the database.
`static 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.
`static void`	`removeByP_L(boolean privateLayout, long logoId)` Removes all the layout set versions where privateLayout = ? and logoId = ? from the database.
`static LayoutSetVersion`	`update(LayoutSetVersion layoutSetVersion)`
`static LayoutSetVersion`	`update(LayoutSetVersion layoutSetVersion, ServiceContext serviceContext)`
`static LayoutSetVersion`	`updateImpl(LayoutSetVersion layoutSetVersion)`

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - LayoutSetVersionUtil
```
public LayoutSetVersionUtil()
```
- Method Detail
  - clearCache
```
public static void clearCache()
```
    See Also:
    
    BasePersistence.clearCache()
  - clearCache
```
public static void clearCache(LayoutSetVersion layoutSetVersion)
```
    See Also:
    
    BasePersistence.clearCache(com.liferay.portal.kernel.model.BaseModel)
  - countWithDynamicQuery
```
public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
```
    See Also:
    
    BasePersistence.countWithDynamicQuery(DynamicQuery)
  - fetchByPrimaryKeys
```
public static Map<Serializable,LayoutSetVersion> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
```
    See Also:
    
    BasePersistence.fetchByPrimaryKeys(Set)
  - findWithDynamicQuery
```
public static List<LayoutSetVersion> findWithDynamicQuery(DynamicQuery dynamicQuery)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery)
  - findWithDynamicQuery
```
public static List<LayoutSetVersion> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                                          int start,
                                                          int end)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
  - findWithDynamicQuery
```
public static List<LayoutSetVersion> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                                          int start,
                                                          int end,
                                                          OrderByComparator<LayoutSetVersion> orderByComparator)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
  - update
```
public static LayoutSetVersion update(LayoutSetVersion layoutSetVersion)
```
    See Also:
    
    BasePersistence.update(com.liferay.portal.kernel.model.BaseModel)
  - update
```
public static LayoutSetVersion update(LayoutSetVersion layoutSetVersion,
                                      ServiceContext serviceContext)
```
    See Also:
    
    BasePersistence.update(com.liferay.portal.kernel.model.BaseModel, ServiceContext)
  - findByLayoutSetId
```
public static 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
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findByLayoutSetId(long layoutSetId,
                                                       int start,
                                                       int end,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator,
                                                       boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetId_First
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static void removeByLayoutSetId(long layoutSetId)
```
    Removes all the layout set versions where layoutSetId = ? from the database.
    
    Parameters:
    
    layoutSetId - the layout set ID
  - countByLayoutSetId
```
public static 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
```
public static 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
```
public static 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
```
public static LayoutSetVersion fetchByLayoutSetId_Version(long layoutSetId,
                                                          int version,
                                                          boolean useFinderCache)
```
    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
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the matching layout set version, or null if a matching layout set version could not be found
  - removeByLayoutSetId_Version
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findByGroupId(long groupId,
                                                   int start,
                                                   int end,
                                                   OrderByComparator<LayoutSetVersion> orderByComparator,
                                                   boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByGroupId_First
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static void removeByGroupId(long groupId)
```
    Removes all the layout set versions where groupId = ? from the database.
    
    Parameters:
    
    groupId - the group ID
  - countByGroupId
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findByGroupId_Version(long groupId,
                                                           int version,
                                                           int start,
                                                           int end,
                                                           OrderByComparator<LayoutSetVersion> orderByComparator,
                                                           boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByGroupId_Version_First
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid)
```
    Returns all the layout set versions where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    Returns:
    
    the matching layout set versions
  - findByLayoutSetPrototypeUuid
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid(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
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid(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
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid,
                                                                  int start,
                                                                  int end,
                                                                  OrderByComparator<LayoutSetVersion> orderByComparator,
                                                                  boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetPrototypeUuid_First
```
public static LayoutSetVersion findByLayoutSetPrototypeUuid_First(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
```
public static LayoutSetVersion fetchByLayoutSetPrototypeUuid_First(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
```
public static LayoutSetVersion findByLayoutSetPrototypeUuid_Last(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
```
public static LayoutSetVersion fetchByLayoutSetPrototypeUuid_Last(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
```
public static LayoutSetVersion[] findByLayoutSetPrototypeUuid_PrevAndNext(long layoutSetVersionId,
                                                                          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
```
public static void removeByLayoutSetPrototypeUuid(String layoutSetPrototypeUuid)
```
    Removes all the layout set versions where layoutSetPrototypeUuid = ? from the database.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
  - countByLayoutSetPrototypeUuid
```
public static int countByLayoutSetPrototypeUuid(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
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(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
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(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
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(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
```
public static List<LayoutSetVersion> findByLayoutSetPrototypeUuid_Version(String layoutSetPrototypeUuid,
                                                                          int version,
                                                                          int start,
                                                                          int end,
                                                                          OrderByComparator<LayoutSetVersion> orderByComparator,
                                                                          boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByLayoutSetPrototypeUuid_Version_First
```
public static LayoutSetVersion findByLayoutSetPrototypeUuid_Version_First(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
```
public static LayoutSetVersion fetchByLayoutSetPrototypeUuid_Version_First(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
```
public static LayoutSetVersion findByLayoutSetPrototypeUuid_Version_Last(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
```
public static LayoutSetVersion fetchByLayoutSetPrototypeUuid_Version_Last(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
```
public static LayoutSetVersion[] findByLayoutSetPrototypeUuid_Version_PrevAndNext(long layoutSetVersionId,
                                                                                  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
```
public static void removeByLayoutSetPrototypeUuid_Version(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
```
public static int countByLayoutSetPrototypeUuid_Version(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
```
public static 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
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findByG_P(long groupId,
                                               boolean privateLayout,
                                               int start,
                                               int end,
                                               OrderByComparator<LayoutSetVersion> orderByComparator,
                                               boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByG_P_First
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static LayoutSetVersion fetchByG_P_Version(long groupId,
                                                  boolean privateLayout,
                                                  int version,
                                                  boolean useFinderCache)
```
    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
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the matching layout set version, or null if a matching layout set version could not be found
  - removeByG_P_Version
```
public static 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
```
public static 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
  - findByC_L
```
public static List<LayoutSetVersion> findByC_L(long companyId,
                                               String layoutSetPrototypeUuid)
```
    Returns all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    companyId - the company ID
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    Returns:
    
    the matching layout set versions
  - findByC_L
```
public static List<LayoutSetVersion> findByC_L(long companyId,
                                               String layoutSetPrototypeUuid,
                                               int start,
                                               int end)
```
    Returns a range of all the layout set versions where companyId = ? and 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:
    
    companyId - the company ID
    
    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
  - findByC_L
```
public static List<LayoutSetVersion> findByC_L(long companyId,
                                               String layoutSetPrototypeUuid,
                                               int start,
                                               int end,
                                               OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where companyId = ? and 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:
    
    companyId - the company ID
    
    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
  - findByC_L
```
public static List<LayoutSetVersion> findByC_L(long companyId,
                                               String layoutSetPrototypeUuid,
                                               int start,
                                               int end,
                                               OrderByComparator<LayoutSetVersion> orderByComparator,
                                               boolean useFinderCache)
```
    Returns an ordered range of all the layout set versions where companyId = ? and 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:
    
    companyId - the company ID
    
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByC_L_First
```
public static LayoutSetVersion findByC_L_First(long companyId,
                                               String layoutSetPrototypeUuid,
                                               OrderByComparator<LayoutSetVersion> orderByComparator)
                                        throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - fetchByC_L_First
```
public static LayoutSetVersion fetchByC_L_First(long companyId,
                                                String layoutSetPrototypeUuid,
                                                OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - findByC_L_Last
```
public static LayoutSetVersion findByC_L_Last(long companyId,
                                              String layoutSetPrototypeUuid,
                                              OrderByComparator<LayoutSetVersion> orderByComparator)
                                       throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - fetchByC_L_Last
```
public static LayoutSetVersion fetchByC_L_Last(long companyId,
                                               String layoutSetPrototypeUuid,
                                               OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - findByC_L_PrevAndNext
```
public static LayoutSetVersion[] findByC_L_PrevAndNext(long layoutSetVersionId,
                                                       long companyId,
                                                       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 companyId = ? and layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    companyId - the company ID
    
    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
  - removeByC_L
```
public static void removeByC_L(long companyId,
                               String layoutSetPrototypeUuid)
```
    Removes all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? from the database.
    
    Parameters:
    
    companyId - the company ID
    
    layoutSetPrototypeUuid - the layout set prototype uuid
  - countByC_L
```
public static int countByC_L(long companyId,
                             String layoutSetPrototypeUuid)
```
    Returns the number of layout set versions where companyId = ? and layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    companyId - the company ID
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    Returns:
    
    the number of matching layout set versions
  - findByC_L_Version
```
public static List<LayoutSetVersion> findByC_L_Version(long companyId,
                                                       String layoutSetPrototypeUuid,
                                                       int version)
```
    Returns all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    companyId - the company ID
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    Returns:
    
    the matching layout set versions
  - findByC_L_Version
```
public static List<LayoutSetVersion> findByC_L_Version(long companyId,
                                                       String layoutSetPrototypeUuid,
                                                       int version,
                                                       int start,
                                                       int end)
```
    Returns a range of all the layout set versions where companyId = ? and 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:
    
    companyId - the company ID
    
    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
  - findByC_L_Version
```
public static List<LayoutSetVersion> findByC_L_Version(long companyId,
                                                       String layoutSetPrototypeUuid,
                                                       int version,
                                                       int start,
                                                       int end,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns an ordered range of all the layout set versions where companyId = ? and 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:
    
    companyId - the company ID
    
    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
  - findByC_L_Version
```
public static List<LayoutSetVersion> findByC_L_Version(long companyId,
                                                       String layoutSetPrototypeUuid,
                                                       int version,
                                                       int start,
                                                       int end,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator,
                                                       boolean useFinderCache)
```
    Returns an ordered range of all the layout set versions where companyId = ? and 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:
    
    companyId - the company ID
    
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByC_L_Version_First
```
public static LayoutSetVersion findByC_L_Version_First(long companyId,
                                                       String layoutSetPrototypeUuid,
                                                       int version,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator)
                                                throws NoSuchLayoutSetVersionException
```
    Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - fetchByC_L_Version_First
```
public static LayoutSetVersion fetchByC_L_Version_First(long companyId,
                                                        String layoutSetPrototypeUuid,
                                                        int version,
                                                        OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the first layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - findByC_L_Version_Last
```
public static LayoutSetVersion findByC_L_Version_Last(long companyId,
                                                      String layoutSetPrototypeUuid,
                                                      int version,
                                                      OrderByComparator<LayoutSetVersion> orderByComparator)
                                               throws NoSuchLayoutSetVersionException
```
    Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - fetchByC_L_Version_Last
```
public static LayoutSetVersion fetchByC_L_Version_Last(long companyId,
                                                       String layoutSetPrototypeUuid,
                                                       int version,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator)
```
    Returns the last layout set version in the ordered set where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    companyId - the company ID
    
    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
  - findByC_L_Version_PrevAndNext
```
public static LayoutSetVersion[] findByC_L_Version_PrevAndNext(long layoutSetVersionId,
                                                               long companyId,
                                                               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 companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    layoutSetVersionId - the primary key of the current layout set version
    
    companyId - the company ID
    
    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
  - removeByC_L_Version
```
public static void removeByC_L_Version(long companyId,
                                       String layoutSetPrototypeUuid,
                                       int version)
```
    Removes all the layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ? from the database.
    
    Parameters:
    
    companyId - the company ID
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
  - countByC_L_Version
```
public static int countByC_L_Version(long companyId,
                                     String layoutSetPrototypeUuid,
                                     int version)
```
    Returns the number of layout set versions where companyId = ? and layoutSetPrototypeUuid = ? and version = ?.
    
    Parameters:
    
    companyId - the company ID
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    version - the version
    
    Returns:
    
    the number of matching layout set versions
  - findByP_L
```
public static 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
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findByP_L(boolean privateLayout,
                                               long logoId,
                                               int start,
                                               int end,
                                               OrderByComparator<LayoutSetVersion> orderByComparator,
                                               boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByP_L_First
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findByP_L_Version(boolean privateLayout,
                                                       long logoId,
                                                       int version,
                                                       int start,
                                                       int end,
                                                       OrderByComparator<LayoutSetVersion> orderByComparator,
                                                       boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of matching layout set versions
  - findByP_L_Version_First
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static 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
```
public static void cacheResult(LayoutSetVersion layoutSetVersion)
```
    Caches the layout set version in the entity cache if it is enabled.
    
    Parameters:
    
    layoutSetVersion - the layout set version
  - cacheResult
```
public static void cacheResult(List<LayoutSetVersion> layoutSetVersions)
```
    Caches the layout set versions in the entity cache if it is enabled.
    
    Parameters:
    
    layoutSetVersions - the layout set versions
  - create
```
public static 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
```
public static 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
```
public static LayoutSetVersion updateImpl(LayoutSetVersion layoutSetVersion)
```
  - findByPrimaryKey
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findAll()
```
    Returns all the layout set versions.
    
    Returns:
    
    the layout set versions
  - findAll
```
public static 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
```
public static 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
```
public static List<LayoutSetVersion> findAll(int start,
                                             int end,
                                             OrderByComparator<LayoutSetVersion> orderByComparator,
                                             boolean useFinderCache)
```
    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)
    
    useFinderCache - whether to use the finder cache
    
    Returns:
    
    the ordered range of layout set versions
  - removeAll
```
public static void removeAll()
```
    Removes all the layout set versions from the database.
  - countAll
```
public static int countAll()
```
    Returns the number of layout set versions.
    
    Returns:
    
    the number of layout set versions
  - getPersistence
```
public static LayoutSetVersionPersistence getPersistence()
```

Class LayoutSetVersionUtil

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

LayoutSetVersionUtil

Method Detail

clearCache

clearCache

countWithDynamicQuery

fetchByPrimaryKeys

findWithDynamicQuery

findWithDynamicQuery

findWithDynamicQuery

update

update

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