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