001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.exception.NoSuchLayoutSetPrototypeException;
020    import com.liferay.portal.kernel.model.LayoutSetPrototype;
021    
022    /**
023     * The persistence interface for the layout set prototype service.
024     *
025     * <p>
026     * Caching information and settings can be found in <code>portal.properties</code>
027     * </p>
028     *
029     * @author Brian Wing Shun Chan
030     * @see com.liferay.portal.service.persistence.impl.LayoutSetPrototypePersistenceImpl
031     * @see LayoutSetPrototypeUtil
032     * @generated
033     */
034    @ProviderType
035    public interface LayoutSetPrototypePersistence extends BasePersistence<LayoutSetPrototype> {
036            /*
037             * NOTE FOR DEVELOPERS:
038             *
039             * Never modify or reference this interface directly. Always use {@link LayoutSetPrototypeUtil} to access the layout set prototype persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
040             */
041    
042            /**
043            * Returns all the layout set prototypes where uuid = &#63;.
044            *
045            * @param uuid the uuid
046            * @return the matching layout set prototypes
047            */
048            public java.util.List<LayoutSetPrototype> findByUuid(java.lang.String uuid);
049    
050            /**
051            * Returns a range of all the layout set prototypes where uuid = &#63;.
052            *
053            * <p>
054            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
055            * </p>
056            *
057            * @param uuid the uuid
058            * @param start the lower bound of the range of layout set prototypes
059            * @param end the upper bound of the range of layout set prototypes (not inclusive)
060            * @return the range of matching layout set prototypes
061            */
062            public java.util.List<LayoutSetPrototype> findByUuid(
063                    java.lang.String uuid, int start, int end);
064    
065            /**
066            * Returns an ordered range of all the layout set prototypes where uuid = &#63;.
067            *
068            * <p>
069            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
070            * </p>
071            *
072            * @param uuid the uuid
073            * @param start the lower bound of the range of layout set prototypes
074            * @param end the upper bound of the range of layout set prototypes (not inclusive)
075            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
076            * @return the ordered range of matching layout set prototypes
077            */
078            public java.util.List<LayoutSetPrototype> findByUuid(
079                    java.lang.String uuid, int start, int end,
080                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
081    
082            /**
083            * Returns an ordered range of all the layout set prototypes where uuid = &#63;.
084            *
085            * <p>
086            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
087            * </p>
088            *
089            * @param uuid the uuid
090            * @param start the lower bound of the range of layout set prototypes
091            * @param end the upper bound of the range of layout set prototypes (not inclusive)
092            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
093            * @param retrieveFromCache whether to retrieve from the finder cache
094            * @return the ordered range of matching layout set prototypes
095            */
096            public java.util.List<LayoutSetPrototype> findByUuid(
097                    java.lang.String uuid, int start, int end,
098                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator,
099                    boolean retrieveFromCache);
100    
101            /**
102            * Returns the first layout set prototype in the ordered set where uuid = &#63;.
103            *
104            * @param uuid the uuid
105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
106            * @return the first matching layout set prototype
107            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
108            */
109            public LayoutSetPrototype findByUuid_First(java.lang.String uuid,
110                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
111                    throws NoSuchLayoutSetPrototypeException;
112    
113            /**
114            * Returns the first layout set prototype in the ordered set where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
118            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
119            */
120            public LayoutSetPrototype fetchByUuid_First(java.lang.String uuid,
121                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
122    
123            /**
124            * Returns the last layout set prototype in the ordered set where uuid = &#63;.
125            *
126            * @param uuid the uuid
127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
128            * @return the last matching layout set prototype
129            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
130            */
131            public LayoutSetPrototype findByUuid_Last(java.lang.String uuid,
132                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
133                    throws NoSuchLayoutSetPrototypeException;
134    
135            /**
136            * Returns the last layout set prototype in the ordered set where uuid = &#63;.
137            *
138            * @param uuid the uuid
139            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
140            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
141            */
142            public LayoutSetPrototype fetchByUuid_Last(java.lang.String uuid,
143                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
144    
145            /**
146            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = &#63;.
147            *
148            * @param layoutSetPrototypeId the primary key of the current layout set prototype
149            * @param uuid the uuid
150            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
151            * @return the previous, current, and next layout set prototype
152            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
153            */
154            public LayoutSetPrototype[] findByUuid_PrevAndNext(
155                    long layoutSetPrototypeId, java.lang.String uuid,
156                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
157                    throws NoSuchLayoutSetPrototypeException;
158    
159            /**
160            * Returns all the layout set prototypes that the user has permission to view where uuid = &#63;.
161            *
162            * @param uuid the uuid
163            * @return the matching layout set prototypes that the user has permission to view
164            */
165            public java.util.List<LayoutSetPrototype> filterFindByUuid(
166                    java.lang.String uuid);
167    
168            /**
169            * Returns a range of all the layout set prototypes that the user has permission to view where uuid = &#63;.
170            *
171            * <p>
172            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
173            * </p>
174            *
175            * @param uuid the uuid
176            * @param start the lower bound of the range of layout set prototypes
177            * @param end the upper bound of the range of layout set prototypes (not inclusive)
178            * @return the range of matching layout set prototypes that the user has permission to view
179            */
180            public java.util.List<LayoutSetPrototype> filterFindByUuid(
181                    java.lang.String uuid, int start, int end);
182    
183            /**
184            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = &#63;.
185            *
186            * <p>
187            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
188            * </p>
189            *
190            * @param uuid the uuid
191            * @param start the lower bound of the range of layout set prototypes
192            * @param end the upper bound of the range of layout set prototypes (not inclusive)
193            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
194            * @return the ordered range of matching layout set prototypes that the user has permission to view
195            */
196            public java.util.List<LayoutSetPrototype> filterFindByUuid(
197                    java.lang.String uuid, int start, int end,
198                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
199    
200            /**
201            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = &#63;.
202            *
203            * @param layoutSetPrototypeId the primary key of the current layout set prototype
204            * @param uuid the uuid
205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
206            * @return the previous, current, and next layout set prototype
207            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
208            */
209            public LayoutSetPrototype[] filterFindByUuid_PrevAndNext(
210                    long layoutSetPrototypeId, java.lang.String uuid,
211                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
212                    throws NoSuchLayoutSetPrototypeException;
213    
214            /**
215            * Removes all the layout set prototypes where uuid = &#63; from the database.
216            *
217            * @param uuid the uuid
218            */
219            public void removeByUuid(java.lang.String uuid);
220    
221            /**
222            * Returns the number of layout set prototypes where uuid = &#63;.
223            *
224            * @param uuid the uuid
225            * @return the number of matching layout set prototypes
226            */
227            public int countByUuid(java.lang.String uuid);
228    
229            /**
230            * Returns the number of layout set prototypes that the user has permission to view where uuid = &#63;.
231            *
232            * @param uuid the uuid
233            * @return the number of matching layout set prototypes that the user has permission to view
234            */
235            public int filterCountByUuid(java.lang.String uuid);
236    
237            /**
238            * Returns all the layout set prototypes where uuid = &#63; and companyId = &#63;.
239            *
240            * @param uuid the uuid
241            * @param companyId the company ID
242            * @return the matching layout set prototypes
243            */
244            public java.util.List<LayoutSetPrototype> findByUuid_C(
245                    java.lang.String uuid, long companyId);
246    
247            /**
248            * Returns a range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
249            *
250            * <p>
251            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
252            * </p>
253            *
254            * @param uuid the uuid
255            * @param companyId the company ID
256            * @param start the lower bound of the range of layout set prototypes
257            * @param end the upper bound of the range of layout set prototypes (not inclusive)
258            * @return the range of matching layout set prototypes
259            */
260            public java.util.List<LayoutSetPrototype> findByUuid_C(
261                    java.lang.String uuid, long companyId, int start, int end);
262    
263            /**
264            * Returns an ordered range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
265            *
266            * <p>
267            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
268            * </p>
269            *
270            * @param uuid the uuid
271            * @param companyId the company ID
272            * @param start the lower bound of the range of layout set prototypes
273            * @param end the upper bound of the range of layout set prototypes (not inclusive)
274            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
275            * @return the ordered range of matching layout set prototypes
276            */
277            public java.util.List<LayoutSetPrototype> findByUuid_C(
278                    java.lang.String uuid, long companyId, int start, int end,
279                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
280    
281            /**
282            * Returns an ordered range of all the layout set prototypes where uuid = &#63; and companyId = &#63;.
283            *
284            * <p>
285            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
286            * </p>
287            *
288            * @param uuid the uuid
289            * @param companyId the company ID
290            * @param start the lower bound of the range of layout set prototypes
291            * @param end the upper bound of the range of layout set prototypes (not inclusive)
292            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
293            * @param retrieveFromCache whether to retrieve from the finder cache
294            * @return the ordered range of matching layout set prototypes
295            */
296            public java.util.List<LayoutSetPrototype> findByUuid_C(
297                    java.lang.String uuid, long companyId, int start, int end,
298                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator,
299                    boolean retrieveFromCache);
300    
301            /**
302            * Returns the first layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
303            *
304            * @param uuid the uuid
305            * @param companyId the company ID
306            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
307            * @return the first matching layout set prototype
308            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
309            */
310            public LayoutSetPrototype findByUuid_C_First(java.lang.String uuid,
311                    long companyId,
312                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
313                    throws NoSuchLayoutSetPrototypeException;
314    
315            /**
316            * Returns the first layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
317            *
318            * @param uuid the uuid
319            * @param companyId the company ID
320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
321            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
322            */
323            public LayoutSetPrototype fetchByUuid_C_First(java.lang.String uuid,
324                    long companyId,
325                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
326    
327            /**
328            * Returns the last layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
329            *
330            * @param uuid the uuid
331            * @param companyId the company ID
332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
333            * @return the last matching layout set prototype
334            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
335            */
336            public LayoutSetPrototype findByUuid_C_Last(java.lang.String uuid,
337                    long companyId,
338                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
339                    throws NoSuchLayoutSetPrototypeException;
340    
341            /**
342            * Returns the last layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
343            *
344            * @param uuid the uuid
345            * @param companyId the company ID
346            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
347            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
348            */
349            public LayoutSetPrototype fetchByUuid_C_Last(java.lang.String uuid,
350                    long companyId,
351                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
352    
353            /**
354            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = &#63; and companyId = &#63;.
355            *
356            * @param layoutSetPrototypeId the primary key of the current layout set prototype
357            * @param uuid the uuid
358            * @param companyId the company ID
359            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
360            * @return the previous, current, and next layout set prototype
361            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
362            */
363            public LayoutSetPrototype[] findByUuid_C_PrevAndNext(
364                    long layoutSetPrototypeId, java.lang.String uuid, long companyId,
365                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
366                    throws NoSuchLayoutSetPrototypeException;
367    
368            /**
369            * Returns all the layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
370            *
371            * @param uuid the uuid
372            * @param companyId the company ID
373            * @return the matching layout set prototypes that the user has permission to view
374            */
375            public java.util.List<LayoutSetPrototype> filterFindByUuid_C(
376                    java.lang.String uuid, long companyId);
377    
378            /**
379            * Returns a range of all the layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
380            *
381            * <p>
382            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
383            * </p>
384            *
385            * @param uuid the uuid
386            * @param companyId the company ID
387            * @param start the lower bound of the range of layout set prototypes
388            * @param end the upper bound of the range of layout set prototypes (not inclusive)
389            * @return the range of matching layout set prototypes that the user has permission to view
390            */
391            public java.util.List<LayoutSetPrototype> filterFindByUuid_C(
392                    java.lang.String uuid, long companyId, int start, int end);
393    
394            /**
395            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = &#63; and companyId = &#63;.
396            *
397            * <p>
398            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
399            * </p>
400            *
401            * @param uuid the uuid
402            * @param companyId the company ID
403            * @param start the lower bound of the range of layout set prototypes
404            * @param end the upper bound of the range of layout set prototypes (not inclusive)
405            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
406            * @return the ordered range of matching layout set prototypes that the user has permission to view
407            */
408            public java.util.List<LayoutSetPrototype> filterFindByUuid_C(
409                    java.lang.String uuid, long companyId, int start, int end,
410                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
411    
412            /**
413            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
414            *
415            * @param layoutSetPrototypeId the primary key of the current layout set prototype
416            * @param uuid the uuid
417            * @param companyId the company ID
418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
419            * @return the previous, current, and next layout set prototype
420            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
421            */
422            public LayoutSetPrototype[] filterFindByUuid_C_PrevAndNext(
423                    long layoutSetPrototypeId, java.lang.String uuid, long companyId,
424                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
425                    throws NoSuchLayoutSetPrototypeException;
426    
427            /**
428            * Removes all the layout set prototypes where uuid = &#63; and companyId = &#63; from the database.
429            *
430            * @param uuid the uuid
431            * @param companyId the company ID
432            */
433            public void removeByUuid_C(java.lang.String uuid, long companyId);
434    
435            /**
436            * Returns the number of layout set prototypes where uuid = &#63; and companyId = &#63;.
437            *
438            * @param uuid the uuid
439            * @param companyId the company ID
440            * @return the number of matching layout set prototypes
441            */
442            public int countByUuid_C(java.lang.String uuid, long companyId);
443    
444            /**
445            * Returns the number of layout set prototypes that the user has permission to view where uuid = &#63; and companyId = &#63;.
446            *
447            * @param uuid the uuid
448            * @param companyId the company ID
449            * @return the number of matching layout set prototypes that the user has permission to view
450            */
451            public int filterCountByUuid_C(java.lang.String uuid, long companyId);
452    
453            /**
454            * Returns all the layout set prototypes where companyId = &#63;.
455            *
456            * @param companyId the company ID
457            * @return the matching layout set prototypes
458            */
459            public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId);
460    
461            /**
462            * Returns a range of all the layout set prototypes where companyId = &#63;.
463            *
464            * <p>
465            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
466            * </p>
467            *
468            * @param companyId the company ID
469            * @param start the lower bound of the range of layout set prototypes
470            * @param end the upper bound of the range of layout set prototypes (not inclusive)
471            * @return the range of matching layout set prototypes
472            */
473            public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId,
474                    int start, int end);
475    
476            /**
477            * Returns an ordered range of all the layout set prototypes where companyId = &#63;.
478            *
479            * <p>
480            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
481            * </p>
482            *
483            * @param companyId the company ID
484            * @param start the lower bound of the range of layout set prototypes
485            * @param end the upper bound of the range of layout set prototypes (not inclusive)
486            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
487            * @return the ordered range of matching layout set prototypes
488            */
489            public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId,
490                    int start, int end,
491                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
492    
493            /**
494            * Returns an ordered range of all the layout set prototypes where companyId = &#63;.
495            *
496            * <p>
497            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
498            * </p>
499            *
500            * @param companyId the company ID
501            * @param start the lower bound of the range of layout set prototypes
502            * @param end the upper bound of the range of layout set prototypes (not inclusive)
503            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
504            * @param retrieveFromCache whether to retrieve from the finder cache
505            * @return the ordered range of matching layout set prototypes
506            */
507            public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId,
508                    int start, int end,
509                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator,
510                    boolean retrieveFromCache);
511    
512            /**
513            * Returns the first layout set prototype in the ordered set where companyId = &#63;.
514            *
515            * @param companyId the company ID
516            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
517            * @return the first matching layout set prototype
518            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
519            */
520            public LayoutSetPrototype findByCompanyId_First(long companyId,
521                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
522                    throws NoSuchLayoutSetPrototypeException;
523    
524            /**
525            * Returns the first layout set prototype in the ordered set where companyId = &#63;.
526            *
527            * @param companyId the company ID
528            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
529            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
530            */
531            public LayoutSetPrototype fetchByCompanyId_First(long companyId,
532                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
533    
534            /**
535            * Returns the last layout set prototype in the ordered set where companyId = &#63;.
536            *
537            * @param companyId the company ID
538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
539            * @return the last matching layout set prototype
540            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
541            */
542            public LayoutSetPrototype findByCompanyId_Last(long companyId,
543                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
544                    throws NoSuchLayoutSetPrototypeException;
545    
546            /**
547            * Returns the last layout set prototype in the ordered set where companyId = &#63;.
548            *
549            * @param companyId the company ID
550            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
551            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
552            */
553            public LayoutSetPrototype fetchByCompanyId_Last(long companyId,
554                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
555    
556            /**
557            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = &#63;.
558            *
559            * @param layoutSetPrototypeId the primary key of the current layout set prototype
560            * @param companyId the company ID
561            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
562            * @return the previous, current, and next layout set prototype
563            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
564            */
565            public LayoutSetPrototype[] findByCompanyId_PrevAndNext(
566                    long layoutSetPrototypeId, long companyId,
567                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
568                    throws NoSuchLayoutSetPrototypeException;
569    
570            /**
571            * Returns all the layout set prototypes that the user has permission to view where companyId = &#63;.
572            *
573            * @param companyId the company ID
574            * @return the matching layout set prototypes that the user has permission to view
575            */
576            public java.util.List<LayoutSetPrototype> filterFindByCompanyId(
577                    long companyId);
578    
579            /**
580            * Returns a range of all the layout set prototypes that the user has permission to view where companyId = &#63;.
581            *
582            * <p>
583            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
584            * </p>
585            *
586            * @param companyId the company ID
587            * @param start the lower bound of the range of layout set prototypes
588            * @param end the upper bound of the range of layout set prototypes (not inclusive)
589            * @return the range of matching layout set prototypes that the user has permission to view
590            */
591            public java.util.List<LayoutSetPrototype> filterFindByCompanyId(
592                    long companyId, int start, int end);
593    
594            /**
595            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = &#63;.
596            *
597            * <p>
598            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
599            * </p>
600            *
601            * @param companyId the company ID
602            * @param start the lower bound of the range of layout set prototypes
603            * @param end the upper bound of the range of layout set prototypes (not inclusive)
604            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
605            * @return the ordered range of matching layout set prototypes that the user has permission to view
606            */
607            public java.util.List<LayoutSetPrototype> filterFindByCompanyId(
608                    long companyId, int start, int end,
609                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
610    
611            /**
612            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = &#63;.
613            *
614            * @param layoutSetPrototypeId the primary key of the current layout set prototype
615            * @param companyId the company ID
616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
617            * @return the previous, current, and next layout set prototype
618            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
619            */
620            public LayoutSetPrototype[] filterFindByCompanyId_PrevAndNext(
621                    long layoutSetPrototypeId, long companyId,
622                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
623                    throws NoSuchLayoutSetPrototypeException;
624    
625            /**
626            * Removes all the layout set prototypes where companyId = &#63; from the database.
627            *
628            * @param companyId the company ID
629            */
630            public void removeByCompanyId(long companyId);
631    
632            /**
633            * Returns the number of layout set prototypes where companyId = &#63;.
634            *
635            * @param companyId the company ID
636            * @return the number of matching layout set prototypes
637            */
638            public int countByCompanyId(long companyId);
639    
640            /**
641            * Returns the number of layout set prototypes that the user has permission to view where companyId = &#63;.
642            *
643            * @param companyId the company ID
644            * @return the number of matching layout set prototypes that the user has permission to view
645            */
646            public int filterCountByCompanyId(long companyId);
647    
648            /**
649            * Returns all the layout set prototypes where companyId = &#63; and active = &#63;.
650            *
651            * @param companyId the company ID
652            * @param active the active
653            * @return the matching layout set prototypes
654            */
655            public java.util.List<LayoutSetPrototype> findByC_A(long companyId,
656                    boolean active);
657    
658            /**
659            * Returns a range of all the layout set prototypes where companyId = &#63; and active = &#63;.
660            *
661            * <p>
662            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
663            * </p>
664            *
665            * @param companyId the company ID
666            * @param active the active
667            * @param start the lower bound of the range of layout set prototypes
668            * @param end the upper bound of the range of layout set prototypes (not inclusive)
669            * @return the range of matching layout set prototypes
670            */
671            public java.util.List<LayoutSetPrototype> findByC_A(long companyId,
672                    boolean active, int start, int end);
673    
674            /**
675            * Returns an ordered range of all the layout set prototypes where companyId = &#63; and active = &#63;.
676            *
677            * <p>
678            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
679            * </p>
680            *
681            * @param companyId the company ID
682            * @param active the active
683            * @param start the lower bound of the range of layout set prototypes
684            * @param end the upper bound of the range of layout set prototypes (not inclusive)
685            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
686            * @return the ordered range of matching layout set prototypes
687            */
688            public java.util.List<LayoutSetPrototype> findByC_A(long companyId,
689                    boolean active, int start, int end,
690                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
691    
692            /**
693            * Returns an ordered range of all the layout set prototypes where companyId = &#63; and active = &#63;.
694            *
695            * <p>
696            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
697            * </p>
698            *
699            * @param companyId the company ID
700            * @param active the active
701            * @param start the lower bound of the range of layout set prototypes
702            * @param end the upper bound of the range of layout set prototypes (not inclusive)
703            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
704            * @param retrieveFromCache whether to retrieve from the finder cache
705            * @return the ordered range of matching layout set prototypes
706            */
707            public java.util.List<LayoutSetPrototype> findByC_A(long companyId,
708                    boolean active, int start, int end,
709                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator,
710                    boolean retrieveFromCache);
711    
712            /**
713            * Returns the first layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
714            *
715            * @param companyId the company ID
716            * @param active the active
717            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
718            * @return the first matching layout set prototype
719            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
720            */
721            public LayoutSetPrototype findByC_A_First(long companyId, boolean active,
722                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
723                    throws NoSuchLayoutSetPrototypeException;
724    
725            /**
726            * Returns the first layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
727            *
728            * @param companyId the company ID
729            * @param active the active
730            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
731            * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
732            */
733            public LayoutSetPrototype fetchByC_A_First(long companyId, boolean active,
734                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
735    
736            /**
737            * Returns the last layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
738            *
739            * @param companyId the company ID
740            * @param active the active
741            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
742            * @return the last matching layout set prototype
743            * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found
744            */
745            public LayoutSetPrototype findByC_A_Last(long companyId, boolean active,
746                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
747                    throws NoSuchLayoutSetPrototypeException;
748    
749            /**
750            * Returns the last layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
751            *
752            * @param companyId the company ID
753            * @param active the active
754            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
755            * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found
756            */
757            public LayoutSetPrototype fetchByC_A_Last(long companyId, boolean active,
758                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
759    
760            /**
761            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = &#63; and active = &#63;.
762            *
763            * @param layoutSetPrototypeId the primary key of the current layout set prototype
764            * @param companyId the company ID
765            * @param active the active
766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
767            * @return the previous, current, and next layout set prototype
768            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
769            */
770            public LayoutSetPrototype[] findByC_A_PrevAndNext(
771                    long layoutSetPrototypeId, long companyId, boolean active,
772                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
773                    throws NoSuchLayoutSetPrototypeException;
774    
775            /**
776            * Returns all the layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
777            *
778            * @param companyId the company ID
779            * @param active the active
780            * @return the matching layout set prototypes that the user has permission to view
781            */
782            public java.util.List<LayoutSetPrototype> filterFindByC_A(long companyId,
783                    boolean active);
784    
785            /**
786            * Returns a range of all the layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
787            *
788            * <p>
789            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
790            * </p>
791            *
792            * @param companyId the company ID
793            * @param active the active
794            * @param start the lower bound of the range of layout set prototypes
795            * @param end the upper bound of the range of layout set prototypes (not inclusive)
796            * @return the range of matching layout set prototypes that the user has permission to view
797            */
798            public java.util.List<LayoutSetPrototype> filterFindByC_A(long companyId,
799                    boolean active, int start, int end);
800    
801            /**
802            * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = &#63; and active = &#63;.
803            *
804            * <p>
805            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
806            * </p>
807            *
808            * @param companyId the company ID
809            * @param active the active
810            * @param start the lower bound of the range of layout set prototypes
811            * @param end the upper bound of the range of layout set prototypes (not inclusive)
812            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
813            * @return the ordered range of matching layout set prototypes that the user has permission to view
814            */
815            public java.util.List<LayoutSetPrototype> filterFindByC_A(long companyId,
816                    boolean active, int start, int end,
817                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
818    
819            /**
820            * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
821            *
822            * @param layoutSetPrototypeId the primary key of the current layout set prototype
823            * @param companyId the company ID
824            * @param active the active
825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
826            * @return the previous, current, and next layout set prototype
827            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
828            */
829            public LayoutSetPrototype[] filterFindByC_A_PrevAndNext(
830                    long layoutSetPrototypeId, long companyId, boolean active,
831                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator)
832                    throws NoSuchLayoutSetPrototypeException;
833    
834            /**
835            * Removes all the layout set prototypes where companyId = &#63; and active = &#63; from the database.
836            *
837            * @param companyId the company ID
838            * @param active the active
839            */
840            public void removeByC_A(long companyId, boolean active);
841    
842            /**
843            * Returns the number of layout set prototypes where companyId = &#63; and active = &#63;.
844            *
845            * @param companyId the company ID
846            * @param active the active
847            * @return the number of matching layout set prototypes
848            */
849            public int countByC_A(long companyId, boolean active);
850    
851            /**
852            * Returns the number of layout set prototypes that the user has permission to view where companyId = &#63; and active = &#63;.
853            *
854            * @param companyId the company ID
855            * @param active the active
856            * @return the number of matching layout set prototypes that the user has permission to view
857            */
858            public int filterCountByC_A(long companyId, boolean active);
859    
860            /**
861            * Caches the layout set prototype in the entity cache if it is enabled.
862            *
863            * @param layoutSetPrototype the layout set prototype
864            */
865            public void cacheResult(LayoutSetPrototype layoutSetPrototype);
866    
867            /**
868            * Caches the layout set prototypes in the entity cache if it is enabled.
869            *
870            * @param layoutSetPrototypes the layout set prototypes
871            */
872            public void cacheResult(
873                    java.util.List<LayoutSetPrototype> layoutSetPrototypes);
874    
875            /**
876            * Creates a new layout set prototype with the primary key. Does not add the layout set prototype to the database.
877            *
878            * @param layoutSetPrototypeId the primary key for the new layout set prototype
879            * @return the new layout set prototype
880            */
881            public LayoutSetPrototype create(long layoutSetPrototypeId);
882    
883            /**
884            * Removes the layout set prototype with the primary key from the database. Also notifies the appropriate model listeners.
885            *
886            * @param layoutSetPrototypeId the primary key of the layout set prototype
887            * @return the layout set prototype that was removed
888            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
889            */
890            public LayoutSetPrototype remove(long layoutSetPrototypeId)
891                    throws NoSuchLayoutSetPrototypeException;
892    
893            public LayoutSetPrototype updateImpl(LayoutSetPrototype layoutSetPrototype);
894    
895            /**
896            * Returns the layout set prototype with the primary key or throws a {@link NoSuchLayoutSetPrototypeException} if it could not be found.
897            *
898            * @param layoutSetPrototypeId the primary key of the layout set prototype
899            * @return the layout set prototype
900            * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found
901            */
902            public LayoutSetPrototype findByPrimaryKey(long layoutSetPrototypeId)
903                    throws NoSuchLayoutSetPrototypeException;
904    
905            /**
906            * Returns the layout set prototype with the primary key or returns <code>null</code> if it could not be found.
907            *
908            * @param layoutSetPrototypeId the primary key of the layout set prototype
909            * @return the layout set prototype, or <code>null</code> if a layout set prototype with the primary key could not be found
910            */
911            public LayoutSetPrototype fetchByPrimaryKey(long layoutSetPrototypeId);
912    
913            @Override
914            public java.util.Map<java.io.Serializable, LayoutSetPrototype> fetchByPrimaryKeys(
915                    java.util.Set<java.io.Serializable> primaryKeys);
916    
917            /**
918            * Returns all the layout set prototypes.
919            *
920            * @return the layout set prototypes
921            */
922            public java.util.List<LayoutSetPrototype> findAll();
923    
924            /**
925            * Returns a range of all the layout set prototypes.
926            *
927            * <p>
928            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
929            * </p>
930            *
931            * @param start the lower bound of the range of layout set prototypes
932            * @param end the upper bound of the range of layout set prototypes (not inclusive)
933            * @return the range of layout set prototypes
934            */
935            public java.util.List<LayoutSetPrototype> findAll(int start, int end);
936    
937            /**
938            * Returns an ordered range of all the layout set prototypes.
939            *
940            * <p>
941            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
942            * </p>
943            *
944            * @param start the lower bound of the range of layout set prototypes
945            * @param end the upper bound of the range of layout set prototypes (not inclusive)
946            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
947            * @return the ordered range of layout set prototypes
948            */
949            public java.util.List<LayoutSetPrototype> findAll(int start, int end,
950                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator);
951    
952            /**
953            * Returns an ordered range of all the layout set prototypes.
954            *
955            * <p>
956            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> 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.
957            * </p>
958            *
959            * @param start the lower bound of the range of layout set prototypes
960            * @param end the upper bound of the range of layout set prototypes (not inclusive)
961            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
962            * @param retrieveFromCache whether to retrieve from the finder cache
963            * @return the ordered range of layout set prototypes
964            */
965            public java.util.List<LayoutSetPrototype> findAll(int start, int end,
966                    com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator,
967                    boolean retrieveFromCache);
968    
969            /**
970            * Removes all the layout set prototypes from the database.
971            */
972            public void removeAll();
973    
974            /**
975            * Returns the number of layout set prototypes.
976            *
977            * @return the number of layout set prototypes
978            */
979            public int countAll();
980    
981            @Override
982            public java.util.Set<java.lang.String> getBadColumnNames();
983    }