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