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.document.library.kernel.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.document.library.kernel.exception.NoSuchFolderException;
020    import com.liferay.document.library.kernel.model.DLFolder;
021    
022    import com.liferay.portal.kernel.service.persistence.BasePersistence;
023    
024    /**
025     * The persistence interface for the document library folder service.
026     *
027     * <p>
028     * Caching information and settings can be found in <code>portal.properties</code>
029     * </p>
030     *
031     * @author Brian Wing Shun Chan
032     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFolderPersistenceImpl
033     * @see DLFolderUtil
034     * @generated
035     */
036    @ProviderType
037    public interface DLFolderPersistence extends BasePersistence<DLFolder> {
038            /*
039             * NOTE FOR DEVELOPERS:
040             *
041             * Never modify or reference this interface directly. Always use {@link DLFolderUtil} to access the document library folder persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
042             */
043    
044            /**
045            * Returns all the document library folders where uuid = &#63;.
046            *
047            * @param uuid the uuid
048            * @return the matching document library folders
049            */
050            public java.util.List<DLFolder> findByUuid(java.lang.String uuid);
051    
052            /**
053            * Returns a range of all the document library folders where uuid = &#63;.
054            *
055            * <p>
056            * 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 DLFolderModelImpl}. 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.
057            * </p>
058            *
059            * @param uuid the uuid
060            * @param start the lower bound of the range of document library folders
061            * @param end the upper bound of the range of document library folders (not inclusive)
062            * @return the range of matching document library folders
063            */
064            public java.util.List<DLFolder> findByUuid(java.lang.String uuid,
065                    int start, int end);
066    
067            /**
068            * Returns an ordered range of all the document library folders where uuid = &#63;.
069            *
070            * <p>
071            * 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 DLFolderModelImpl}. 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.
072            * </p>
073            *
074            * @param uuid the uuid
075            * @param start the lower bound of the range of document library folders
076            * @param end the upper bound of the range of document library folders (not inclusive)
077            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
078            * @return the ordered range of matching document library folders
079            */
080            public java.util.List<DLFolder> findByUuid(java.lang.String uuid,
081                    int start, int end,
082                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
083    
084            /**
085            * Returns an ordered range of all the document library folders where uuid = &#63;.
086            *
087            * <p>
088            * 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 DLFolderModelImpl}. 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.
089            * </p>
090            *
091            * @param uuid the uuid
092            * @param start the lower bound of the range of document library folders
093            * @param end the upper bound of the range of document library folders (not inclusive)
094            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
095            * @param retrieveFromCache whether to retrieve from the finder cache
096            * @return the ordered range of matching document library folders
097            */
098            public java.util.List<DLFolder> findByUuid(java.lang.String uuid,
099                    int start, int end,
100                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
101                    boolean retrieveFromCache);
102    
103            /**
104            * Returns the first document library folder 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 first matching document library folder
109            * @throws NoSuchFolderException if a matching document library folder could not be found
110            */
111            public DLFolder findByUuid_First(java.lang.String uuid,
112                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
113                    throws NoSuchFolderException;
114    
115            /**
116            * Returns the first document library folder 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 first matching document library folder, or <code>null</code> if a matching document library folder could not be found
121            */
122            public DLFolder fetchByUuid_First(java.lang.String uuid,
123                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
124    
125            /**
126            * Returns the last document library folder in the ordered set where uuid = &#63;.
127            *
128            * @param uuid the uuid
129            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
130            * @return the last matching document library folder
131            * @throws NoSuchFolderException if a matching document library folder could not be found
132            */
133            public DLFolder findByUuid_Last(java.lang.String uuid,
134                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
135                    throws NoSuchFolderException;
136    
137            /**
138            * Returns the last document library folder in the ordered set where uuid = &#63;.
139            *
140            * @param uuid the uuid
141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
142            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
143            */
144            public DLFolder fetchByUuid_Last(java.lang.String uuid,
145                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
146    
147            /**
148            * Returns the document library folders before and after the current document library folder in the ordered set where uuid = &#63;.
149            *
150            * @param folderId the primary key of the current document library folder
151            * @param uuid the uuid
152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
153            * @return the previous, current, and next document library folder
154            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
155            */
156            public DLFolder[] findByUuid_PrevAndNext(long folderId,
157                    java.lang.String uuid,
158                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
159                    throws NoSuchFolderException;
160    
161            /**
162            * Removes all the document library folders where uuid = &#63; from the database.
163            *
164            * @param uuid the uuid
165            */
166            public void removeByUuid(java.lang.String uuid);
167    
168            /**
169            * Returns the number of document library folders where uuid = &#63;.
170            *
171            * @param uuid the uuid
172            * @return the number of matching document library folders
173            */
174            public int countByUuid(java.lang.String uuid);
175    
176            /**
177            * Returns the document library folder where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
178            *
179            * @param uuid the uuid
180            * @param groupId the group ID
181            * @return the matching document library folder
182            * @throws NoSuchFolderException if a matching document library folder could not be found
183            */
184            public DLFolder findByUUID_G(java.lang.String uuid, long groupId)
185                    throws NoSuchFolderException;
186    
187            /**
188            * Returns the document library folder where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
189            *
190            * @param uuid the uuid
191            * @param groupId the group ID
192            * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found
193            */
194            public DLFolder fetchByUUID_G(java.lang.String uuid, long groupId);
195    
196            /**
197            * Returns the document library folder where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
198            *
199            * @param uuid the uuid
200            * @param groupId the group ID
201            * @param retrieveFromCache whether to retrieve from the finder cache
202            * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found
203            */
204            public DLFolder fetchByUUID_G(java.lang.String uuid, long groupId,
205                    boolean retrieveFromCache);
206    
207            /**
208            * Removes the document library folder where uuid = &#63; and groupId = &#63; from the database.
209            *
210            * @param uuid the uuid
211            * @param groupId the group ID
212            * @return the document library folder that was removed
213            */
214            public DLFolder removeByUUID_G(java.lang.String uuid, long groupId)
215                    throws NoSuchFolderException;
216    
217            /**
218            * Returns the number of document library folders where uuid = &#63; and groupId = &#63;.
219            *
220            * @param uuid the uuid
221            * @param groupId the group ID
222            * @return the number of matching document library folders
223            */
224            public int countByUUID_G(java.lang.String uuid, long groupId);
225    
226            /**
227            * Returns all the document library folders where uuid = &#63; and companyId = &#63;.
228            *
229            * @param uuid the uuid
230            * @param companyId the company ID
231            * @return the matching document library folders
232            */
233            public java.util.List<DLFolder> findByUuid_C(java.lang.String uuid,
234                    long companyId);
235    
236            /**
237            * Returns a range of all the document library folders where uuid = &#63; and companyId = &#63;.
238            *
239            * <p>
240            * 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 DLFolderModelImpl}. 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.
241            * </p>
242            *
243            * @param uuid the uuid
244            * @param companyId the company ID
245            * @param start the lower bound of the range of document library folders
246            * @param end the upper bound of the range of document library folders (not inclusive)
247            * @return the range of matching document library folders
248            */
249            public java.util.List<DLFolder> findByUuid_C(java.lang.String uuid,
250                    long companyId, int start, int end);
251    
252            /**
253            * Returns an ordered range of all the document library folders where uuid = &#63; and companyId = &#63;.
254            *
255            * <p>
256            * 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 DLFolderModelImpl}. 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.
257            * </p>
258            *
259            * @param uuid the uuid
260            * @param companyId the company ID
261            * @param start the lower bound of the range of document library folders
262            * @param end the upper bound of the range of document library folders (not inclusive)
263            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
264            * @return the ordered range of matching document library folders
265            */
266            public java.util.List<DLFolder> findByUuid_C(java.lang.String uuid,
267                    long companyId, int start, int end,
268                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
269    
270            /**
271            * Returns an ordered range of all the document library folders where uuid = &#63; and companyId = &#63;.
272            *
273            * <p>
274            * 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 DLFolderModelImpl}. 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.
275            * </p>
276            *
277            * @param uuid the uuid
278            * @param companyId the company ID
279            * @param start the lower bound of the range of document library folders
280            * @param end the upper bound of the range of document library folders (not inclusive)
281            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
282            * @param retrieveFromCache whether to retrieve from the finder cache
283            * @return the ordered range of matching document library folders
284            */
285            public java.util.List<DLFolder> findByUuid_C(java.lang.String uuid,
286                    long companyId, int start, int end,
287                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
288                    boolean retrieveFromCache);
289    
290            /**
291            * Returns the first document library folder in the ordered set where uuid = &#63; and companyId = &#63;.
292            *
293            * @param uuid the uuid
294            * @param companyId the company ID
295            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
296            * @return the first matching document library folder
297            * @throws NoSuchFolderException if a matching document library folder could not be found
298            */
299            public DLFolder findByUuid_C_First(java.lang.String uuid, long companyId,
300                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
301                    throws NoSuchFolderException;
302    
303            /**
304            * Returns the first document library folder in the ordered set where uuid = &#63; and companyId = &#63;.
305            *
306            * @param uuid the uuid
307            * @param companyId the company ID
308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
309            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
310            */
311            public DLFolder fetchByUuid_C_First(java.lang.String uuid, long companyId,
312                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
313    
314            /**
315            * Returns the last document library folder 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 last matching document library folder
321            * @throws NoSuchFolderException if a matching document library folder could not be found
322            */
323            public DLFolder findByUuid_C_Last(java.lang.String uuid, long companyId,
324                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
325                    throws NoSuchFolderException;
326    
327            /**
328            * Returns the last document library folder in the ordered set where uuid = &#63; and companyId = &#63;.
329            *
330            * @param uuid the uuid
331            * @param companyId the company ID
332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
333            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
334            */
335            public DLFolder fetchByUuid_C_Last(java.lang.String uuid, long companyId,
336                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
337    
338            /**
339            * Returns the document library folders before and after the current document library folder in the ordered set where uuid = &#63; and companyId = &#63;.
340            *
341            * @param folderId the primary key of the current document library folder
342            * @param uuid the uuid
343            * @param companyId the company ID
344            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
345            * @return the previous, current, and next document library folder
346            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
347            */
348            public DLFolder[] findByUuid_C_PrevAndNext(long folderId,
349                    java.lang.String uuid, long companyId,
350                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
351                    throws NoSuchFolderException;
352    
353            /**
354            * Removes all the document library folders where uuid = &#63; and companyId = &#63; from the database.
355            *
356            * @param uuid the uuid
357            * @param companyId the company ID
358            */
359            public void removeByUuid_C(java.lang.String uuid, long companyId);
360    
361            /**
362            * Returns the number of document library folders where uuid = &#63; and companyId = &#63;.
363            *
364            * @param uuid the uuid
365            * @param companyId the company ID
366            * @return the number of matching document library folders
367            */
368            public int countByUuid_C(java.lang.String uuid, long companyId);
369    
370            /**
371            * Returns all the document library folders where groupId = &#63;.
372            *
373            * @param groupId the group ID
374            * @return the matching document library folders
375            */
376            public java.util.List<DLFolder> findByGroupId(long groupId);
377    
378            /**
379            * Returns a range of all the document library folders where groupId = &#63;.
380            *
381            * <p>
382            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
383            * </p>
384            *
385            * @param groupId the group ID
386            * @param start the lower bound of the range of document library folders
387            * @param end the upper bound of the range of document library folders (not inclusive)
388            * @return the range of matching document library folders
389            */
390            public java.util.List<DLFolder> findByGroupId(long groupId, int start,
391                    int end);
392    
393            /**
394            * Returns an ordered range of all the document library folders where groupId = &#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 DLFolderModelImpl}. 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 groupId the group ID
401            * @param start the lower bound of the range of document library folders
402            * @param end the upper bound of the range of document library folders (not inclusive)
403            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
404            * @return the ordered range of matching document library folders
405            */
406            public java.util.List<DLFolder> findByGroupId(long groupId, int start,
407                    int end,
408                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
409    
410            /**
411            * Returns an ordered range of all the document library folders where groupId = &#63;.
412            *
413            * <p>
414            * 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 DLFolderModelImpl}. 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.
415            * </p>
416            *
417            * @param groupId the group ID
418            * @param start the lower bound of the range of document library folders
419            * @param end the upper bound of the range of document library folders (not inclusive)
420            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
421            * @param retrieveFromCache whether to retrieve from the finder cache
422            * @return the ordered range of matching document library folders
423            */
424            public java.util.List<DLFolder> findByGroupId(long groupId, int start,
425                    int end,
426                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
427                    boolean retrieveFromCache);
428    
429            /**
430            * Returns the first document library folder in the ordered set where groupId = &#63;.
431            *
432            * @param groupId the group ID
433            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
434            * @return the first matching document library folder
435            * @throws NoSuchFolderException if a matching document library folder could not be found
436            */
437            public DLFolder findByGroupId_First(long groupId,
438                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
439                    throws NoSuchFolderException;
440    
441            /**
442            * Returns the first document library folder in the ordered set where groupId = &#63;.
443            *
444            * @param groupId the group ID
445            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
446            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
447            */
448            public DLFolder fetchByGroupId_First(long groupId,
449                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
450    
451            /**
452            * Returns the last document library folder in the ordered set where groupId = &#63;.
453            *
454            * @param groupId the group ID
455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
456            * @return the last matching document library folder
457            * @throws NoSuchFolderException if a matching document library folder could not be found
458            */
459            public DLFolder findByGroupId_Last(long groupId,
460                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
461                    throws NoSuchFolderException;
462    
463            /**
464            * Returns the last document library folder in the ordered set where groupId = &#63;.
465            *
466            * @param groupId the group ID
467            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
468            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
469            */
470            public DLFolder fetchByGroupId_Last(long groupId,
471                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
472    
473            /**
474            * Returns the document library folders before and after the current document library folder in the ordered set where groupId = &#63;.
475            *
476            * @param folderId the primary key of the current document library folder
477            * @param groupId the group ID
478            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
479            * @return the previous, current, and next document library folder
480            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
481            */
482            public DLFolder[] findByGroupId_PrevAndNext(long folderId, long groupId,
483                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
484                    throws NoSuchFolderException;
485    
486            /**
487            * Returns all the document library folders that the user has permission to view where groupId = &#63;.
488            *
489            * @param groupId the group ID
490            * @return the matching document library folders that the user has permission to view
491            */
492            public java.util.List<DLFolder> filterFindByGroupId(long groupId);
493    
494            /**
495            * Returns a range of all the document library folders that the user has permission to view where groupId = &#63;.
496            *
497            * <p>
498            * 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 DLFolderModelImpl}. 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.
499            * </p>
500            *
501            * @param groupId the group ID
502            * @param start the lower bound of the range of document library folders
503            * @param end the upper bound of the range of document library folders (not inclusive)
504            * @return the range of matching document library folders that the user has permission to view
505            */
506            public java.util.List<DLFolder> filterFindByGroupId(long groupId,
507                    int start, int end);
508    
509            /**
510            * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = &#63;.
511            *
512            * <p>
513            * 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 DLFolderModelImpl}. 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.
514            * </p>
515            *
516            * @param groupId the group ID
517            * @param start the lower bound of the range of document library folders
518            * @param end the upper bound of the range of document library folders (not inclusive)
519            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
520            * @return the ordered range of matching document library folders that the user has permission to view
521            */
522            public java.util.List<DLFolder> filterFindByGroupId(long groupId,
523                    int start, int end,
524                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
525    
526            /**
527            * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = &#63;.
528            *
529            * @param folderId the primary key of the current document library folder
530            * @param groupId the group ID
531            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
532            * @return the previous, current, and next document library folder
533            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
534            */
535            public DLFolder[] filterFindByGroupId_PrevAndNext(long folderId,
536                    long groupId,
537                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
538                    throws NoSuchFolderException;
539    
540            /**
541            * Removes all the document library folders where groupId = &#63; from the database.
542            *
543            * @param groupId the group ID
544            */
545            public void removeByGroupId(long groupId);
546    
547            /**
548            * Returns the number of document library folders where groupId = &#63;.
549            *
550            * @param groupId the group ID
551            * @return the number of matching document library folders
552            */
553            public int countByGroupId(long groupId);
554    
555            /**
556            * Returns the number of document library folders that the user has permission to view where groupId = &#63;.
557            *
558            * @param groupId the group ID
559            * @return the number of matching document library folders that the user has permission to view
560            */
561            public int filterCountByGroupId(long groupId);
562    
563            /**
564            * Returns all the document library folders where companyId = &#63;.
565            *
566            * @param companyId the company ID
567            * @return the matching document library folders
568            */
569            public java.util.List<DLFolder> findByCompanyId(long companyId);
570    
571            /**
572            * Returns a range of all the document library folders where companyId = &#63;.
573            *
574            * <p>
575            * 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 DLFolderModelImpl}. 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.
576            * </p>
577            *
578            * @param companyId the company ID
579            * @param start the lower bound of the range of document library folders
580            * @param end the upper bound of the range of document library folders (not inclusive)
581            * @return the range of matching document library folders
582            */
583            public java.util.List<DLFolder> findByCompanyId(long companyId, int start,
584                    int end);
585    
586            /**
587            * Returns an ordered range of all the document library folders where companyId = &#63;.
588            *
589            * <p>
590            * 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 DLFolderModelImpl}. 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.
591            * </p>
592            *
593            * @param companyId the company ID
594            * @param start the lower bound of the range of document library folders
595            * @param end the upper bound of the range of document library folders (not inclusive)
596            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
597            * @return the ordered range of matching document library folders
598            */
599            public java.util.List<DLFolder> findByCompanyId(long companyId, int start,
600                    int end,
601                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
602    
603            /**
604            * Returns an ordered range of all the document library folders where companyId = &#63;.
605            *
606            * <p>
607            * 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 DLFolderModelImpl}. 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.
608            * </p>
609            *
610            * @param companyId the company ID
611            * @param start the lower bound of the range of document library folders
612            * @param end the upper bound of the range of document library folders (not inclusive)
613            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
614            * @param retrieveFromCache whether to retrieve from the finder cache
615            * @return the ordered range of matching document library folders
616            */
617            public java.util.List<DLFolder> findByCompanyId(long companyId, int start,
618                    int end,
619                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
620                    boolean retrieveFromCache);
621    
622            /**
623            * Returns the first document library folder in the ordered set where companyId = &#63;.
624            *
625            * @param companyId the company ID
626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
627            * @return the first matching document library folder
628            * @throws NoSuchFolderException if a matching document library folder could not be found
629            */
630            public DLFolder findByCompanyId_First(long companyId,
631                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
632                    throws NoSuchFolderException;
633    
634            /**
635            * Returns the first document library folder in the ordered set where companyId = &#63;.
636            *
637            * @param companyId the company ID
638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
639            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
640            */
641            public DLFolder fetchByCompanyId_First(long companyId,
642                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
643    
644            /**
645            * Returns the last document library folder in the ordered set where companyId = &#63;.
646            *
647            * @param companyId the company ID
648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
649            * @return the last matching document library folder
650            * @throws NoSuchFolderException if a matching document library folder could not be found
651            */
652            public DLFolder findByCompanyId_Last(long companyId,
653                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
654                    throws NoSuchFolderException;
655    
656            /**
657            * Returns the last document library folder in the ordered set where companyId = &#63;.
658            *
659            * @param companyId the company ID
660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
661            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
662            */
663            public DLFolder fetchByCompanyId_Last(long companyId,
664                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
665    
666            /**
667            * Returns the document library folders before and after the current document library folder in the ordered set where companyId = &#63;.
668            *
669            * @param folderId the primary key of the current document library folder
670            * @param companyId the company ID
671            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
672            * @return the previous, current, and next document library folder
673            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
674            */
675            public DLFolder[] findByCompanyId_PrevAndNext(long folderId,
676                    long companyId,
677                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
678                    throws NoSuchFolderException;
679    
680            /**
681            * Removes all the document library folders where companyId = &#63; from the database.
682            *
683            * @param companyId the company ID
684            */
685            public void removeByCompanyId(long companyId);
686    
687            /**
688            * Returns the number of document library folders where companyId = &#63;.
689            *
690            * @param companyId the company ID
691            * @return the number of matching document library folders
692            */
693            public int countByCompanyId(long companyId);
694    
695            /**
696            * Returns all the document library folders where repositoryId = &#63;.
697            *
698            * @param repositoryId the repository ID
699            * @return the matching document library folders
700            */
701            public java.util.List<DLFolder> findByRepositoryId(long repositoryId);
702    
703            /**
704            * Returns a range of all the document library folders where repositoryId = &#63;.
705            *
706            * <p>
707            * 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 DLFolderModelImpl}. 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.
708            * </p>
709            *
710            * @param repositoryId the repository ID
711            * @param start the lower bound of the range of document library folders
712            * @param end the upper bound of the range of document library folders (not inclusive)
713            * @return the range of matching document library folders
714            */
715            public java.util.List<DLFolder> findByRepositoryId(long repositoryId,
716                    int start, int end);
717    
718            /**
719            * Returns an ordered range of all the document library folders where repositoryId = &#63;.
720            *
721            * <p>
722            * 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 DLFolderModelImpl}. 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.
723            * </p>
724            *
725            * @param repositoryId the repository ID
726            * @param start the lower bound of the range of document library folders
727            * @param end the upper bound of the range of document library folders (not inclusive)
728            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
729            * @return the ordered range of matching document library folders
730            */
731            public java.util.List<DLFolder> findByRepositoryId(long repositoryId,
732                    int start, int end,
733                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
734    
735            /**
736            * Returns an ordered range of all the document library folders where repositoryId = &#63;.
737            *
738            * <p>
739            * 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 DLFolderModelImpl}. 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.
740            * </p>
741            *
742            * @param repositoryId the repository ID
743            * @param start the lower bound of the range of document library folders
744            * @param end the upper bound of the range of document library folders (not inclusive)
745            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
746            * @param retrieveFromCache whether to retrieve from the finder cache
747            * @return the ordered range of matching document library folders
748            */
749            public java.util.List<DLFolder> findByRepositoryId(long repositoryId,
750                    int start, int end,
751                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
752                    boolean retrieveFromCache);
753    
754            /**
755            * Returns the first document library folder in the ordered set where repositoryId = &#63;.
756            *
757            * @param repositoryId the repository ID
758            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
759            * @return the first matching document library folder
760            * @throws NoSuchFolderException if a matching document library folder could not be found
761            */
762            public DLFolder findByRepositoryId_First(long repositoryId,
763                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
764                    throws NoSuchFolderException;
765    
766            /**
767            * Returns the first document library folder in the ordered set where repositoryId = &#63;.
768            *
769            * @param repositoryId the repository ID
770            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
771            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
772            */
773            public DLFolder fetchByRepositoryId_First(long repositoryId,
774                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
775    
776            /**
777            * Returns the last document library folder in the ordered set where repositoryId = &#63;.
778            *
779            * @param repositoryId the repository ID
780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
781            * @return the last matching document library folder
782            * @throws NoSuchFolderException if a matching document library folder could not be found
783            */
784            public DLFolder findByRepositoryId_Last(long repositoryId,
785                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
786                    throws NoSuchFolderException;
787    
788            /**
789            * Returns the last document library folder in the ordered set where repositoryId = &#63;.
790            *
791            * @param repositoryId the repository ID
792            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
793            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
794            */
795            public DLFolder fetchByRepositoryId_Last(long repositoryId,
796                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
797    
798            /**
799            * Returns the document library folders before and after the current document library folder in the ordered set where repositoryId = &#63;.
800            *
801            * @param folderId the primary key of the current document library folder
802            * @param repositoryId the repository ID
803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
804            * @return the previous, current, and next document library folder
805            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
806            */
807            public DLFolder[] findByRepositoryId_PrevAndNext(long folderId,
808                    long repositoryId,
809                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
810                    throws NoSuchFolderException;
811    
812            /**
813            * Removes all the document library folders where repositoryId = &#63; from the database.
814            *
815            * @param repositoryId the repository ID
816            */
817            public void removeByRepositoryId(long repositoryId);
818    
819            /**
820            * Returns the number of document library folders where repositoryId = &#63;.
821            *
822            * @param repositoryId the repository ID
823            * @return the number of matching document library folders
824            */
825            public int countByRepositoryId(long repositoryId);
826    
827            /**
828            * Returns all the document library folders where groupId = &#63; and parentFolderId = &#63;.
829            *
830            * @param groupId the group ID
831            * @param parentFolderId the parent folder ID
832            * @return the matching document library folders
833            */
834            public java.util.List<DLFolder> findByG_P(long groupId, long parentFolderId);
835    
836            /**
837            * Returns a range of all the document library folders where groupId = &#63; and parentFolderId = &#63;.
838            *
839            * <p>
840            * 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 DLFolderModelImpl}. 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.
841            * </p>
842            *
843            * @param groupId the group ID
844            * @param parentFolderId the parent folder ID
845            * @param start the lower bound of the range of document library folders
846            * @param end the upper bound of the range of document library folders (not inclusive)
847            * @return the range of matching document library folders
848            */
849            public java.util.List<DLFolder> findByG_P(long groupId,
850                    long parentFolderId, int start, int end);
851    
852            /**
853            * Returns an ordered range of all the document library folders where groupId = &#63; and parentFolderId = &#63;.
854            *
855            * <p>
856            * 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 DLFolderModelImpl}. 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.
857            * </p>
858            *
859            * @param groupId the group ID
860            * @param parentFolderId the parent folder ID
861            * @param start the lower bound of the range of document library folders
862            * @param end the upper bound of the range of document library folders (not inclusive)
863            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
864            * @return the ordered range of matching document library folders
865            */
866            public java.util.List<DLFolder> findByG_P(long groupId,
867                    long parentFolderId, int start, int end,
868                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
869    
870            /**
871            * Returns an ordered range of all the document library folders where groupId = &#63; and parentFolderId = &#63;.
872            *
873            * <p>
874            * 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 DLFolderModelImpl}. 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.
875            * </p>
876            *
877            * @param groupId the group ID
878            * @param parentFolderId the parent folder ID
879            * @param start the lower bound of the range of document library folders
880            * @param end the upper bound of the range of document library folders (not inclusive)
881            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
882            * @param retrieveFromCache whether to retrieve from the finder cache
883            * @return the ordered range of matching document library folders
884            */
885            public java.util.List<DLFolder> findByG_P(long groupId,
886                    long parentFolderId, int start, int end,
887                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
888                    boolean retrieveFromCache);
889    
890            /**
891            * Returns the first document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
892            *
893            * @param groupId the group ID
894            * @param parentFolderId the parent folder ID
895            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
896            * @return the first matching document library folder
897            * @throws NoSuchFolderException if a matching document library folder could not be found
898            */
899            public DLFolder findByG_P_First(long groupId, long parentFolderId,
900                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
901                    throws NoSuchFolderException;
902    
903            /**
904            * Returns the first document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
905            *
906            * @param groupId the group ID
907            * @param parentFolderId the parent folder ID
908            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
909            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
910            */
911            public DLFolder fetchByG_P_First(long groupId, long parentFolderId,
912                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
913    
914            /**
915            * Returns the last document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
916            *
917            * @param groupId the group ID
918            * @param parentFolderId the parent folder ID
919            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
920            * @return the last matching document library folder
921            * @throws NoSuchFolderException if a matching document library folder could not be found
922            */
923            public DLFolder findByG_P_Last(long groupId, long parentFolderId,
924                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
925                    throws NoSuchFolderException;
926    
927            /**
928            * Returns the last document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
929            *
930            * @param groupId the group ID
931            * @param parentFolderId the parent folder ID
932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
933            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
934            */
935            public DLFolder fetchByG_P_Last(long groupId, long parentFolderId,
936                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
937    
938            /**
939            * Returns the document library folders before and after the current document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63;.
940            *
941            * @param folderId the primary key of the current document library folder
942            * @param groupId the group ID
943            * @param parentFolderId the parent folder ID
944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
945            * @return the previous, current, and next document library folder
946            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
947            */
948            public DLFolder[] findByG_P_PrevAndNext(long folderId, long groupId,
949                    long parentFolderId,
950                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
951                    throws NoSuchFolderException;
952    
953            /**
954            * Returns all the document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
955            *
956            * @param groupId the group ID
957            * @param parentFolderId the parent folder ID
958            * @return the matching document library folders that the user has permission to view
959            */
960            public java.util.List<DLFolder> filterFindByG_P(long groupId,
961                    long parentFolderId);
962    
963            /**
964            * Returns a range of all the document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
965            *
966            * <p>
967            * 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 DLFolderModelImpl}. 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.
968            * </p>
969            *
970            * @param groupId the group ID
971            * @param parentFolderId the parent folder ID
972            * @param start the lower bound of the range of document library folders
973            * @param end the upper bound of the range of document library folders (not inclusive)
974            * @return the range of matching document library folders that the user has permission to view
975            */
976            public java.util.List<DLFolder> filterFindByG_P(long groupId,
977                    long parentFolderId, int start, int end);
978    
979            /**
980            * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63;.
981            *
982            * <p>
983            * 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 DLFolderModelImpl}. 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.
984            * </p>
985            *
986            * @param groupId the group ID
987            * @param parentFolderId the parent folder ID
988            * @param start the lower bound of the range of document library folders
989            * @param end the upper bound of the range of document library folders (not inclusive)
990            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
991            * @return the ordered range of matching document library folders that the user has permission to view
992            */
993            public java.util.List<DLFolder> filterFindByG_P(long groupId,
994                    long parentFolderId, int start, int end,
995                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
996    
997            /**
998            * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
999            *
1000            * @param folderId the primary key of the current document library folder
1001            * @param groupId the group ID
1002            * @param parentFolderId the parent folder ID
1003            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1004            * @return the previous, current, and next document library folder
1005            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
1006            */
1007            public DLFolder[] filterFindByG_P_PrevAndNext(long folderId, long groupId,
1008                    long parentFolderId,
1009                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1010                    throws NoSuchFolderException;
1011    
1012            /**
1013            * Removes all the document library folders where groupId = &#63; and parentFolderId = &#63; from the database.
1014            *
1015            * @param groupId the group ID
1016            * @param parentFolderId the parent folder ID
1017            */
1018            public void removeByG_P(long groupId, long parentFolderId);
1019    
1020            /**
1021            * Returns the number of document library folders where groupId = &#63; and parentFolderId = &#63;.
1022            *
1023            * @param groupId the group ID
1024            * @param parentFolderId the parent folder ID
1025            * @return the number of matching document library folders
1026            */
1027            public int countByG_P(long groupId, long parentFolderId);
1028    
1029            /**
1030            * Returns the number of document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63;.
1031            *
1032            * @param groupId the group ID
1033            * @param parentFolderId the parent folder ID
1034            * @return the number of matching document library folders that the user has permission to view
1035            */
1036            public int filterCountByG_P(long groupId, long parentFolderId);
1037    
1038            /**
1039            * Returns all the document library folders where companyId = &#63; and status &ne; &#63;.
1040            *
1041            * @param companyId the company ID
1042            * @param status the status
1043            * @return the matching document library folders
1044            */
1045            public java.util.List<DLFolder> findByC_NotS(long companyId, int status);
1046    
1047            /**
1048            * Returns a range of all the document library folders where companyId = &#63; and status &ne; &#63;.
1049            *
1050            * <p>
1051            * 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 DLFolderModelImpl}. 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.
1052            * </p>
1053            *
1054            * @param companyId the company ID
1055            * @param status the status
1056            * @param start the lower bound of the range of document library folders
1057            * @param end the upper bound of the range of document library folders (not inclusive)
1058            * @return the range of matching document library folders
1059            */
1060            public java.util.List<DLFolder> findByC_NotS(long companyId, int status,
1061                    int start, int end);
1062    
1063            /**
1064            * Returns an ordered range of all the document library folders where companyId = &#63; and status &ne; &#63;.
1065            *
1066            * <p>
1067            * 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 DLFolderModelImpl}. 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.
1068            * </p>
1069            *
1070            * @param companyId the company ID
1071            * @param status the status
1072            * @param start the lower bound of the range of document library folders
1073            * @param end the upper bound of the range of document library folders (not inclusive)
1074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1075            * @return the ordered range of matching document library folders
1076            */
1077            public java.util.List<DLFolder> findByC_NotS(long companyId, int status,
1078                    int start, int end,
1079                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1080    
1081            /**
1082            * Returns an ordered range of all the document library folders where companyId = &#63; and status &ne; &#63;.
1083            *
1084            * <p>
1085            * 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 DLFolderModelImpl}. 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.
1086            * </p>
1087            *
1088            * @param companyId the company ID
1089            * @param status the status
1090            * @param start the lower bound of the range of document library folders
1091            * @param end the upper bound of the range of document library folders (not inclusive)
1092            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1093            * @param retrieveFromCache whether to retrieve from the finder cache
1094            * @return the ordered range of matching document library folders
1095            */
1096            public java.util.List<DLFolder> findByC_NotS(long companyId, int status,
1097                    int start, int end,
1098                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
1099                    boolean retrieveFromCache);
1100    
1101            /**
1102            * Returns the first document library folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1103            *
1104            * @param companyId the company ID
1105            * @param status the status
1106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1107            * @return the first matching document library folder
1108            * @throws NoSuchFolderException if a matching document library folder could not be found
1109            */
1110            public DLFolder findByC_NotS_First(long companyId, int status,
1111                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1112                    throws NoSuchFolderException;
1113    
1114            /**
1115            * Returns the first document library folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1116            *
1117            * @param companyId the company ID
1118            * @param status the status
1119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1120            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
1121            */
1122            public DLFolder fetchByC_NotS_First(long companyId, int status,
1123                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1124    
1125            /**
1126            * Returns the last document library folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1127            *
1128            * @param companyId the company ID
1129            * @param status the status
1130            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1131            * @return the last matching document library folder
1132            * @throws NoSuchFolderException if a matching document library folder could not be found
1133            */
1134            public DLFolder findByC_NotS_Last(long companyId, int status,
1135                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1136                    throws NoSuchFolderException;
1137    
1138            /**
1139            * Returns the last document library folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1140            *
1141            * @param companyId the company ID
1142            * @param status the status
1143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1144            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
1145            */
1146            public DLFolder fetchByC_NotS_Last(long companyId, int status,
1147                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1148    
1149            /**
1150            * Returns the document library folders before and after the current document library folder in the ordered set where companyId = &#63; and status &ne; &#63;.
1151            *
1152            * @param folderId the primary key of the current document library folder
1153            * @param companyId the company ID
1154            * @param status the status
1155            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1156            * @return the previous, current, and next document library folder
1157            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
1158            */
1159            public DLFolder[] findByC_NotS_PrevAndNext(long folderId, long companyId,
1160                    int status,
1161                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1162                    throws NoSuchFolderException;
1163    
1164            /**
1165            * Removes all the document library folders where companyId = &#63; and status &ne; &#63; from the database.
1166            *
1167            * @param companyId the company ID
1168            * @param status the status
1169            */
1170            public void removeByC_NotS(long companyId, int status);
1171    
1172            /**
1173            * Returns the number of document library folders where companyId = &#63; and status &ne; &#63;.
1174            *
1175            * @param companyId the company ID
1176            * @param status the status
1177            * @return the number of matching document library folders
1178            */
1179            public int countByC_NotS(long companyId, int status);
1180    
1181            /**
1182            * Returns the document library folder where repositoryId = &#63; and mountPoint = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
1183            *
1184            * @param repositoryId the repository ID
1185            * @param mountPoint the mount point
1186            * @return the matching document library folder
1187            * @throws NoSuchFolderException if a matching document library folder could not be found
1188            */
1189            public DLFolder findByR_M(long repositoryId, boolean mountPoint)
1190                    throws NoSuchFolderException;
1191    
1192            /**
1193            * Returns the document library folder where repositoryId = &#63; and mountPoint = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1194            *
1195            * @param repositoryId the repository ID
1196            * @param mountPoint the mount point
1197            * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found
1198            */
1199            public DLFolder fetchByR_M(long repositoryId, boolean mountPoint);
1200    
1201            /**
1202            * Returns the document library folder where repositoryId = &#63; and mountPoint = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1203            *
1204            * @param repositoryId the repository ID
1205            * @param mountPoint the mount point
1206            * @param retrieveFromCache whether to retrieve from the finder cache
1207            * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found
1208            */
1209            public DLFolder fetchByR_M(long repositoryId, boolean mountPoint,
1210                    boolean retrieveFromCache);
1211    
1212            /**
1213            * Removes the document library folder where repositoryId = &#63; and mountPoint = &#63; from the database.
1214            *
1215            * @param repositoryId the repository ID
1216            * @param mountPoint the mount point
1217            * @return the document library folder that was removed
1218            */
1219            public DLFolder removeByR_M(long repositoryId, boolean mountPoint)
1220                    throws NoSuchFolderException;
1221    
1222            /**
1223            * Returns the number of document library folders where repositoryId = &#63; and mountPoint = &#63;.
1224            *
1225            * @param repositoryId the repository ID
1226            * @param mountPoint the mount point
1227            * @return the number of matching document library folders
1228            */
1229            public int countByR_M(long repositoryId, boolean mountPoint);
1230    
1231            /**
1232            * Returns all the document library folders where repositoryId = &#63; and parentFolderId = &#63;.
1233            *
1234            * @param repositoryId the repository ID
1235            * @param parentFolderId the parent folder ID
1236            * @return the matching document library folders
1237            */
1238            public java.util.List<DLFolder> findByR_P(long repositoryId,
1239                    long parentFolderId);
1240    
1241            /**
1242            * Returns a range of all the document library folders where repositoryId = &#63; and parentFolderId = &#63;.
1243            *
1244            * <p>
1245            * 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 DLFolderModelImpl}. 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.
1246            * </p>
1247            *
1248            * @param repositoryId the repository ID
1249            * @param parentFolderId the parent folder ID
1250            * @param start the lower bound of the range of document library folders
1251            * @param end the upper bound of the range of document library folders (not inclusive)
1252            * @return the range of matching document library folders
1253            */
1254            public java.util.List<DLFolder> findByR_P(long repositoryId,
1255                    long parentFolderId, int start, int end);
1256    
1257            /**
1258            * Returns an ordered range of all the document library folders where repositoryId = &#63; and parentFolderId = &#63;.
1259            *
1260            * <p>
1261            * 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 DLFolderModelImpl}. 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.
1262            * </p>
1263            *
1264            * @param repositoryId the repository ID
1265            * @param parentFolderId the parent folder ID
1266            * @param start the lower bound of the range of document library folders
1267            * @param end the upper bound of the range of document library folders (not inclusive)
1268            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1269            * @return the ordered range of matching document library folders
1270            */
1271            public java.util.List<DLFolder> findByR_P(long repositoryId,
1272                    long parentFolderId, int start, int end,
1273                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1274    
1275            /**
1276            * Returns an ordered range of all the document library folders where repositoryId = &#63; and parentFolderId = &#63;.
1277            *
1278            * <p>
1279            * 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 DLFolderModelImpl}. 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.
1280            * </p>
1281            *
1282            * @param repositoryId the repository ID
1283            * @param parentFolderId the parent folder ID
1284            * @param start the lower bound of the range of document library folders
1285            * @param end the upper bound of the range of document library folders (not inclusive)
1286            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1287            * @param retrieveFromCache whether to retrieve from the finder cache
1288            * @return the ordered range of matching document library folders
1289            */
1290            public java.util.List<DLFolder> findByR_P(long repositoryId,
1291                    long parentFolderId, int start, int end,
1292                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
1293                    boolean retrieveFromCache);
1294    
1295            /**
1296            * Returns the first document library folder in the ordered set where repositoryId = &#63; and parentFolderId = &#63;.
1297            *
1298            * @param repositoryId the repository ID
1299            * @param parentFolderId the parent folder ID
1300            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1301            * @return the first matching document library folder
1302            * @throws NoSuchFolderException if a matching document library folder could not be found
1303            */
1304            public DLFolder findByR_P_First(long repositoryId, long parentFolderId,
1305                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1306                    throws NoSuchFolderException;
1307    
1308            /**
1309            * Returns the first document library folder in the ordered set where repositoryId = &#63; and parentFolderId = &#63;.
1310            *
1311            * @param repositoryId the repository ID
1312            * @param parentFolderId the parent folder ID
1313            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1314            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
1315            */
1316            public DLFolder fetchByR_P_First(long repositoryId, long parentFolderId,
1317                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1318    
1319            /**
1320            * Returns the last document library folder in the ordered set where repositoryId = &#63; and parentFolderId = &#63;.
1321            *
1322            * @param repositoryId the repository ID
1323            * @param parentFolderId the parent folder ID
1324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1325            * @return the last matching document library folder
1326            * @throws NoSuchFolderException if a matching document library folder could not be found
1327            */
1328            public DLFolder findByR_P_Last(long repositoryId, long parentFolderId,
1329                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1330                    throws NoSuchFolderException;
1331    
1332            /**
1333            * Returns the last document library folder in the ordered set where repositoryId = &#63; and parentFolderId = &#63;.
1334            *
1335            * @param repositoryId the repository ID
1336            * @param parentFolderId the parent folder ID
1337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1338            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
1339            */
1340            public DLFolder fetchByR_P_Last(long repositoryId, long parentFolderId,
1341                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1342    
1343            /**
1344            * Returns the document library folders before and after the current document library folder in the ordered set where repositoryId = &#63; and parentFolderId = &#63;.
1345            *
1346            * @param folderId the primary key of the current document library folder
1347            * @param repositoryId the repository ID
1348            * @param parentFolderId the parent folder ID
1349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1350            * @return the previous, current, and next document library folder
1351            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
1352            */
1353            public DLFolder[] findByR_P_PrevAndNext(long folderId, long repositoryId,
1354                    long parentFolderId,
1355                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1356                    throws NoSuchFolderException;
1357    
1358            /**
1359            * Removes all the document library folders where repositoryId = &#63; and parentFolderId = &#63; from the database.
1360            *
1361            * @param repositoryId the repository ID
1362            * @param parentFolderId the parent folder ID
1363            */
1364            public void removeByR_P(long repositoryId, long parentFolderId);
1365    
1366            /**
1367            * Returns the number of document library folders where repositoryId = &#63; and parentFolderId = &#63;.
1368            *
1369            * @param repositoryId the repository ID
1370            * @param parentFolderId the parent folder ID
1371            * @return the number of matching document library folders
1372            */
1373            public int countByR_P(long repositoryId, long parentFolderId);
1374    
1375            /**
1376            * Returns all the document library folders where parentFolderId = &#63; and name = &#63;.
1377            *
1378            * @param parentFolderId the parent folder ID
1379            * @param name the name
1380            * @return the matching document library folders
1381            */
1382            public java.util.List<DLFolder> findByP_N(long parentFolderId,
1383                    java.lang.String name);
1384    
1385            /**
1386            * Returns a range of all the document library folders where parentFolderId = &#63; and name = &#63;.
1387            *
1388            * <p>
1389            * 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 DLFolderModelImpl}. 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.
1390            * </p>
1391            *
1392            * @param parentFolderId the parent folder ID
1393            * @param name the name
1394            * @param start the lower bound of the range of document library folders
1395            * @param end the upper bound of the range of document library folders (not inclusive)
1396            * @return the range of matching document library folders
1397            */
1398            public java.util.List<DLFolder> findByP_N(long parentFolderId,
1399                    java.lang.String name, int start, int end);
1400    
1401            /**
1402            * Returns an ordered range of all the document library folders where parentFolderId = &#63; and name = &#63;.
1403            *
1404            * <p>
1405            * 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 DLFolderModelImpl}. 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.
1406            * </p>
1407            *
1408            * @param parentFolderId the parent folder ID
1409            * @param name the name
1410            * @param start the lower bound of the range of document library folders
1411            * @param end the upper bound of the range of document library folders (not inclusive)
1412            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1413            * @return the ordered range of matching document library folders
1414            */
1415            public java.util.List<DLFolder> findByP_N(long parentFolderId,
1416                    java.lang.String name, int start, int end,
1417                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1418    
1419            /**
1420            * Returns an ordered range of all the document library folders where parentFolderId = &#63; and name = &#63;.
1421            *
1422            * <p>
1423            * 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 DLFolderModelImpl}. 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.
1424            * </p>
1425            *
1426            * @param parentFolderId the parent folder ID
1427            * @param name the name
1428            * @param start the lower bound of the range of document library folders
1429            * @param end the upper bound of the range of document library folders (not inclusive)
1430            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1431            * @param retrieveFromCache whether to retrieve from the finder cache
1432            * @return the ordered range of matching document library folders
1433            */
1434            public java.util.List<DLFolder> findByP_N(long parentFolderId,
1435                    java.lang.String name, int start, int end,
1436                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
1437                    boolean retrieveFromCache);
1438    
1439            /**
1440            * Returns the first document library folder in the ordered set where parentFolderId = &#63; and name = &#63;.
1441            *
1442            * @param parentFolderId the parent folder ID
1443            * @param name the name
1444            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1445            * @return the first matching document library folder
1446            * @throws NoSuchFolderException if a matching document library folder could not be found
1447            */
1448            public DLFolder findByP_N_First(long parentFolderId, java.lang.String name,
1449                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1450                    throws NoSuchFolderException;
1451    
1452            /**
1453            * Returns the first document library folder in the ordered set where parentFolderId = &#63; and name = &#63;.
1454            *
1455            * @param parentFolderId the parent folder ID
1456            * @param name the name
1457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1458            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
1459            */
1460            public DLFolder fetchByP_N_First(long parentFolderId,
1461                    java.lang.String name,
1462                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1463    
1464            /**
1465            * Returns the last document library folder in the ordered set where parentFolderId = &#63; and name = &#63;.
1466            *
1467            * @param parentFolderId the parent folder ID
1468            * @param name the name
1469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1470            * @return the last matching document library folder
1471            * @throws NoSuchFolderException if a matching document library folder could not be found
1472            */
1473            public DLFolder findByP_N_Last(long parentFolderId, java.lang.String name,
1474                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1475                    throws NoSuchFolderException;
1476    
1477            /**
1478            * Returns the last document library folder in the ordered set where parentFolderId = &#63; and name = &#63;.
1479            *
1480            * @param parentFolderId the parent folder ID
1481            * @param name the name
1482            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1483            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
1484            */
1485            public DLFolder fetchByP_N_Last(long parentFolderId, java.lang.String name,
1486                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1487    
1488            /**
1489            * Returns the document library folders before and after the current document library folder in the ordered set where parentFolderId = &#63; and name = &#63;.
1490            *
1491            * @param folderId the primary key of the current document library folder
1492            * @param parentFolderId the parent folder ID
1493            * @param name the name
1494            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1495            * @return the previous, current, and next document library folder
1496            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
1497            */
1498            public DLFolder[] findByP_N_PrevAndNext(long folderId, long parentFolderId,
1499                    java.lang.String name,
1500                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1501                    throws NoSuchFolderException;
1502    
1503            /**
1504            * Removes all the document library folders where parentFolderId = &#63; and name = &#63; from the database.
1505            *
1506            * @param parentFolderId the parent folder ID
1507            * @param name the name
1508            */
1509            public void removeByP_N(long parentFolderId, java.lang.String name);
1510    
1511            /**
1512            * Returns the number of document library folders where parentFolderId = &#63; and name = &#63;.
1513            *
1514            * @param parentFolderId the parent folder ID
1515            * @param name the name
1516            * @return the number of matching document library folders
1517            */
1518            public int countByP_N(long parentFolderId, java.lang.String name);
1519    
1520            /**
1521            * Returns all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1522            *
1523            * @param groupId the group ID
1524            * @param mountPoint the mount point
1525            * @param parentFolderId the parent folder ID
1526            * @return the matching document library folders
1527            */
1528            public java.util.List<DLFolder> findByG_M_P(long groupId,
1529                    boolean mountPoint, long parentFolderId);
1530    
1531            /**
1532            * Returns a range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1533            *
1534            * <p>
1535            * 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 DLFolderModelImpl}. 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.
1536            * </p>
1537            *
1538            * @param groupId the group ID
1539            * @param mountPoint the mount point
1540            * @param parentFolderId the parent folder ID
1541            * @param start the lower bound of the range of document library folders
1542            * @param end the upper bound of the range of document library folders (not inclusive)
1543            * @return the range of matching document library folders
1544            */
1545            public java.util.List<DLFolder> findByG_M_P(long groupId,
1546                    boolean mountPoint, long parentFolderId, int start, int end);
1547    
1548            /**
1549            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1550            *
1551            * <p>
1552            * 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 DLFolderModelImpl}. 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.
1553            * </p>
1554            *
1555            * @param groupId the group ID
1556            * @param mountPoint the mount point
1557            * @param parentFolderId the parent folder ID
1558            * @param start the lower bound of the range of document library folders
1559            * @param end the upper bound of the range of document library folders (not inclusive)
1560            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1561            * @return the ordered range of matching document library folders
1562            */
1563            public java.util.List<DLFolder> findByG_M_P(long groupId,
1564                    boolean mountPoint, long parentFolderId, int start, int end,
1565                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1566    
1567            /**
1568            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1569            *
1570            * <p>
1571            * 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 DLFolderModelImpl}. 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.
1572            * </p>
1573            *
1574            * @param groupId the group ID
1575            * @param mountPoint the mount point
1576            * @param parentFolderId the parent folder ID
1577            * @param start the lower bound of the range of document library folders
1578            * @param end the upper bound of the range of document library folders (not inclusive)
1579            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1580            * @param retrieveFromCache whether to retrieve from the finder cache
1581            * @return the ordered range of matching document library folders
1582            */
1583            public java.util.List<DLFolder> findByG_M_P(long groupId,
1584                    boolean mountPoint, long parentFolderId, int start, int end,
1585                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
1586                    boolean retrieveFromCache);
1587    
1588            /**
1589            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1590            *
1591            * @param groupId the group ID
1592            * @param mountPoint the mount point
1593            * @param parentFolderId the parent folder ID
1594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1595            * @return the first matching document library folder
1596            * @throws NoSuchFolderException if a matching document library folder could not be found
1597            */
1598            public DLFolder findByG_M_P_First(long groupId, boolean mountPoint,
1599                    long parentFolderId,
1600                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1601                    throws NoSuchFolderException;
1602    
1603            /**
1604            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1605            *
1606            * @param groupId the group ID
1607            * @param mountPoint the mount point
1608            * @param parentFolderId the parent folder ID
1609            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1610            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
1611            */
1612            public DLFolder fetchByG_M_P_First(long groupId, boolean mountPoint,
1613                    long parentFolderId,
1614                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1615    
1616            /**
1617            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1618            *
1619            * @param groupId the group ID
1620            * @param mountPoint the mount point
1621            * @param parentFolderId the parent folder ID
1622            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1623            * @return the last matching document library folder
1624            * @throws NoSuchFolderException if a matching document library folder could not be found
1625            */
1626            public DLFolder findByG_M_P_Last(long groupId, boolean mountPoint,
1627                    long parentFolderId,
1628                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1629                    throws NoSuchFolderException;
1630    
1631            /**
1632            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1633            *
1634            * @param groupId the group ID
1635            * @param mountPoint the mount point
1636            * @param parentFolderId the parent folder ID
1637            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1638            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
1639            */
1640            public DLFolder fetchByG_M_P_Last(long groupId, boolean mountPoint,
1641                    long parentFolderId,
1642                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1643    
1644            /**
1645            * Returns the document library folders before and after the current document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1646            *
1647            * @param folderId the primary key of the current document library folder
1648            * @param groupId the group ID
1649            * @param mountPoint the mount point
1650            * @param parentFolderId the parent folder ID
1651            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1652            * @return the previous, current, and next document library folder
1653            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
1654            */
1655            public DLFolder[] findByG_M_P_PrevAndNext(long folderId, long groupId,
1656                    boolean mountPoint, long parentFolderId,
1657                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1658                    throws NoSuchFolderException;
1659    
1660            /**
1661            * Returns all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1662            *
1663            * @param groupId the group ID
1664            * @param mountPoint the mount point
1665            * @param parentFolderId the parent folder ID
1666            * @return the matching document library folders that the user has permission to view
1667            */
1668            public java.util.List<DLFolder> filterFindByG_M_P(long groupId,
1669                    boolean mountPoint, long parentFolderId);
1670    
1671            /**
1672            * Returns a range of all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1673            *
1674            * <p>
1675            * 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 DLFolderModelImpl}. 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.
1676            * </p>
1677            *
1678            * @param groupId the group ID
1679            * @param mountPoint the mount point
1680            * @param parentFolderId the parent folder ID
1681            * @param start the lower bound of the range of document library folders
1682            * @param end the upper bound of the range of document library folders (not inclusive)
1683            * @return the range of matching document library folders that the user has permission to view
1684            */
1685            public java.util.List<DLFolder> filterFindByG_M_P(long groupId,
1686                    boolean mountPoint, long parentFolderId, int start, int end);
1687    
1688            /**
1689            * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1690            *
1691            * <p>
1692            * 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 DLFolderModelImpl}. 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.
1693            * </p>
1694            *
1695            * @param groupId the group ID
1696            * @param mountPoint the mount point
1697            * @param parentFolderId the parent folder ID
1698            * @param start the lower bound of the range of document library folders
1699            * @param end the upper bound of the range of document library folders (not inclusive)
1700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1701            * @return the ordered range of matching document library folders that the user has permission to view
1702            */
1703            public java.util.List<DLFolder> filterFindByG_M_P(long groupId,
1704                    boolean mountPoint, long parentFolderId, int start, int end,
1705                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1706    
1707            /**
1708            * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1709            *
1710            * @param folderId the primary key of the current document library folder
1711            * @param groupId the group ID
1712            * @param mountPoint the mount point
1713            * @param parentFolderId the parent folder ID
1714            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1715            * @return the previous, current, and next document library folder
1716            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
1717            */
1718            public DLFolder[] filterFindByG_M_P_PrevAndNext(long folderId,
1719                    long groupId, boolean mountPoint, long parentFolderId,
1720                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1721                    throws NoSuchFolderException;
1722    
1723            /**
1724            * Removes all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; from the database.
1725            *
1726            * @param groupId the group ID
1727            * @param mountPoint the mount point
1728            * @param parentFolderId the parent folder ID
1729            */
1730            public void removeByG_M_P(long groupId, boolean mountPoint,
1731                    long parentFolderId);
1732    
1733            /**
1734            * Returns the number of document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1735            *
1736            * @param groupId the group ID
1737            * @param mountPoint the mount point
1738            * @param parentFolderId the parent folder ID
1739            * @return the number of matching document library folders
1740            */
1741            public int countByG_M_P(long groupId, boolean mountPoint,
1742                    long parentFolderId);
1743    
1744            /**
1745            * Returns the number of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63;.
1746            *
1747            * @param groupId the group ID
1748            * @param mountPoint the mount point
1749            * @param parentFolderId the parent folder ID
1750            * @return the number of matching document library folders that the user has permission to view
1751            */
1752            public int filterCountByG_M_P(long groupId, boolean mountPoint,
1753                    long parentFolderId);
1754    
1755            /**
1756            * Returns the document library folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or throws a {@link NoSuchFolderException} if it could not be found.
1757            *
1758            * @param groupId the group ID
1759            * @param parentFolderId the parent folder ID
1760            * @param name the name
1761            * @return the matching document library folder
1762            * @throws NoSuchFolderException if a matching document library folder could not be found
1763            */
1764            public DLFolder findByG_P_N(long groupId, long parentFolderId,
1765                    java.lang.String name) throws NoSuchFolderException;
1766    
1767            /**
1768            * Returns the document library folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1769            *
1770            * @param groupId the group ID
1771            * @param parentFolderId the parent folder ID
1772            * @param name the name
1773            * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found
1774            */
1775            public DLFolder fetchByG_P_N(long groupId, long parentFolderId,
1776                    java.lang.String name);
1777    
1778            /**
1779            * Returns the document library folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1780            *
1781            * @param groupId the group ID
1782            * @param parentFolderId the parent folder ID
1783            * @param name the name
1784            * @param retrieveFromCache whether to retrieve from the finder cache
1785            * @return the matching document library folder, or <code>null</code> if a matching document library folder could not be found
1786            */
1787            public DLFolder fetchByG_P_N(long groupId, long parentFolderId,
1788                    java.lang.String name, boolean retrieveFromCache);
1789    
1790            /**
1791            * Removes the document library folder where groupId = &#63; and parentFolderId = &#63; and name = &#63; from the database.
1792            *
1793            * @param groupId the group ID
1794            * @param parentFolderId the parent folder ID
1795            * @param name the name
1796            * @return the document library folder that was removed
1797            */
1798            public DLFolder removeByG_P_N(long groupId, long parentFolderId,
1799                    java.lang.String name) throws NoSuchFolderException;
1800    
1801            /**
1802            * Returns the number of document library folders where groupId = &#63; and parentFolderId = &#63; and name = &#63;.
1803            *
1804            * @param groupId the group ID
1805            * @param parentFolderId the parent folder ID
1806            * @param name the name
1807            * @return the number of matching document library folders
1808            */
1809            public int countByG_P_N(long groupId, long parentFolderId,
1810                    java.lang.String name);
1811    
1812            /**
1813            * Returns all the document library folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1814            *
1815            * @param folderId the folder ID
1816            * @param companyId the company ID
1817            * @param parentFolderId the parent folder ID
1818            * @param status the status
1819            * @return the matching document library folders
1820            */
1821            public java.util.List<DLFolder> findByF_C_P_NotS(long folderId,
1822                    long companyId, long parentFolderId, int status);
1823    
1824            /**
1825            * Returns a range of all the document library folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1826            *
1827            * <p>
1828            * 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 DLFolderModelImpl}. 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.
1829            * </p>
1830            *
1831            * @param folderId the folder ID
1832            * @param companyId the company ID
1833            * @param parentFolderId the parent folder ID
1834            * @param status the status
1835            * @param start the lower bound of the range of document library folders
1836            * @param end the upper bound of the range of document library folders (not inclusive)
1837            * @return the range of matching document library folders
1838            */
1839            public java.util.List<DLFolder> findByF_C_P_NotS(long folderId,
1840                    long companyId, long parentFolderId, int status, int start, int end);
1841    
1842            /**
1843            * Returns an ordered range of all the document library folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1844            *
1845            * <p>
1846            * 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 DLFolderModelImpl}. 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.
1847            * </p>
1848            *
1849            * @param folderId the folder ID
1850            * @param companyId the company ID
1851            * @param parentFolderId the parent folder ID
1852            * @param status the status
1853            * @param start the lower bound of the range of document library folders
1854            * @param end the upper bound of the range of document library folders (not inclusive)
1855            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1856            * @return the ordered range of matching document library folders
1857            */
1858            public java.util.List<DLFolder> findByF_C_P_NotS(long folderId,
1859                    long companyId, long parentFolderId, int status, int start, int end,
1860                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1861    
1862            /**
1863            * Returns an ordered range of all the document library folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1864            *
1865            * <p>
1866            * 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 DLFolderModelImpl}. 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.
1867            * </p>
1868            *
1869            * @param folderId the folder ID
1870            * @param companyId the company ID
1871            * @param parentFolderId the parent folder ID
1872            * @param status the status
1873            * @param start the lower bound of the range of document library folders
1874            * @param end the upper bound of the range of document library folders (not inclusive)
1875            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1876            * @param retrieveFromCache whether to retrieve from the finder cache
1877            * @return the ordered range of matching document library folders
1878            */
1879            public java.util.List<DLFolder> findByF_C_P_NotS(long folderId,
1880                    long companyId, long parentFolderId, int status, int start, int end,
1881                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
1882                    boolean retrieveFromCache);
1883    
1884            /**
1885            * Returns the first document library folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1886            *
1887            * @param folderId the folder ID
1888            * @param companyId the company ID
1889            * @param parentFolderId the parent folder ID
1890            * @param status the status
1891            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1892            * @return the first matching document library folder
1893            * @throws NoSuchFolderException if a matching document library folder could not be found
1894            */
1895            public DLFolder findByF_C_P_NotS_First(long folderId, long companyId,
1896                    long parentFolderId, int status,
1897                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1898                    throws NoSuchFolderException;
1899    
1900            /**
1901            * Returns the first document library folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1902            *
1903            * @param folderId the folder ID
1904            * @param companyId the company ID
1905            * @param parentFolderId the parent folder ID
1906            * @param status the status
1907            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1908            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
1909            */
1910            public DLFolder fetchByF_C_P_NotS_First(long folderId, long companyId,
1911                    long parentFolderId, int status,
1912                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1913    
1914            /**
1915            * Returns the last document library folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1916            *
1917            * @param folderId the folder ID
1918            * @param companyId the company ID
1919            * @param parentFolderId the parent folder ID
1920            * @param status the status
1921            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1922            * @return the last matching document library folder
1923            * @throws NoSuchFolderException if a matching document library folder could not be found
1924            */
1925            public DLFolder findByF_C_P_NotS_Last(long folderId, long companyId,
1926                    long parentFolderId, int status,
1927                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
1928                    throws NoSuchFolderException;
1929    
1930            /**
1931            * Returns the last document library folder in the ordered set where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1932            *
1933            * @param folderId the folder ID
1934            * @param companyId the company ID
1935            * @param parentFolderId the parent folder ID
1936            * @param status the status
1937            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1938            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
1939            */
1940            public DLFolder fetchByF_C_P_NotS_Last(long folderId, long companyId,
1941                    long parentFolderId, int status,
1942                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
1943    
1944            /**
1945            * Removes all the document library folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63; from the database.
1946            *
1947            * @param folderId the folder ID
1948            * @param companyId the company ID
1949            * @param parentFolderId the parent folder ID
1950            * @param status the status
1951            */
1952            public void removeByF_C_P_NotS(long folderId, long companyId,
1953                    long parentFolderId, int status);
1954    
1955            /**
1956            * Returns the number of document library folders where folderId &gt; &#63; and companyId = &#63; and parentFolderId = &#63; and status &ne; &#63;.
1957            *
1958            * @param folderId the folder ID
1959            * @param companyId the company ID
1960            * @param parentFolderId the parent folder ID
1961            * @param status the status
1962            * @return the number of matching document library folders
1963            */
1964            public int countByF_C_P_NotS(long folderId, long companyId,
1965                    long parentFolderId, int status);
1966    
1967            /**
1968            * Returns all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
1969            *
1970            * @param groupId the group ID
1971            * @param mountPoint the mount point
1972            * @param parentFolderId the parent folder ID
1973            * @param hidden the hidden
1974            * @return the matching document library folders
1975            */
1976            public java.util.List<DLFolder> findByG_M_P_H(long groupId,
1977                    boolean mountPoint, long parentFolderId, boolean hidden);
1978    
1979            /**
1980            * Returns a range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
1981            *
1982            * <p>
1983            * 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 DLFolderModelImpl}. 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.
1984            * </p>
1985            *
1986            * @param groupId the group ID
1987            * @param mountPoint the mount point
1988            * @param parentFolderId the parent folder ID
1989            * @param hidden the hidden
1990            * @param start the lower bound of the range of document library folders
1991            * @param end the upper bound of the range of document library folders (not inclusive)
1992            * @return the range of matching document library folders
1993            */
1994            public java.util.List<DLFolder> findByG_M_P_H(long groupId,
1995                    boolean mountPoint, long parentFolderId, boolean hidden, int start,
1996                    int end);
1997    
1998            /**
1999            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2000            *
2001            * <p>
2002            * 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 DLFolderModelImpl}. 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.
2003            * </p>
2004            *
2005            * @param groupId the group ID
2006            * @param mountPoint the mount point
2007            * @param parentFolderId the parent folder ID
2008            * @param hidden the hidden
2009            * @param start the lower bound of the range of document library folders
2010            * @param end the upper bound of the range of document library folders (not inclusive)
2011            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2012            * @return the ordered range of matching document library folders
2013            */
2014            public java.util.List<DLFolder> findByG_M_P_H(long groupId,
2015                    boolean mountPoint, long parentFolderId, boolean hidden, int start,
2016                    int end,
2017                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2018    
2019            /**
2020            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2021            *
2022            * <p>
2023            * 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 DLFolderModelImpl}. 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.
2024            * </p>
2025            *
2026            * @param groupId the group ID
2027            * @param mountPoint the mount point
2028            * @param parentFolderId the parent folder ID
2029            * @param hidden the hidden
2030            * @param start the lower bound of the range of document library folders
2031            * @param end the upper bound of the range of document library folders (not inclusive)
2032            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2033            * @param retrieveFromCache whether to retrieve from the finder cache
2034            * @return the ordered range of matching document library folders
2035            */
2036            public java.util.List<DLFolder> findByG_M_P_H(long groupId,
2037                    boolean mountPoint, long parentFolderId, boolean hidden, int start,
2038                    int end,
2039                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
2040                    boolean retrieveFromCache);
2041    
2042            /**
2043            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2044            *
2045            * @param groupId the group ID
2046            * @param mountPoint the mount point
2047            * @param parentFolderId the parent folder ID
2048            * @param hidden the hidden
2049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2050            * @return the first matching document library folder
2051            * @throws NoSuchFolderException if a matching document library folder could not be found
2052            */
2053            public DLFolder findByG_M_P_H_First(long groupId, boolean mountPoint,
2054                    long parentFolderId, boolean hidden,
2055                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2056                    throws NoSuchFolderException;
2057    
2058            /**
2059            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2060            *
2061            * @param groupId the group ID
2062            * @param mountPoint the mount point
2063            * @param parentFolderId the parent folder ID
2064            * @param hidden the hidden
2065            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2066            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
2067            */
2068            public DLFolder fetchByG_M_P_H_First(long groupId, boolean mountPoint,
2069                    long parentFolderId, boolean hidden,
2070                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2071    
2072            /**
2073            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2074            *
2075            * @param groupId the group ID
2076            * @param mountPoint the mount point
2077            * @param parentFolderId the parent folder ID
2078            * @param hidden the hidden
2079            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2080            * @return the last matching document library folder
2081            * @throws NoSuchFolderException if a matching document library folder could not be found
2082            */
2083            public DLFolder findByG_M_P_H_Last(long groupId, boolean mountPoint,
2084                    long parentFolderId, boolean hidden,
2085                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2086                    throws NoSuchFolderException;
2087    
2088            /**
2089            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2090            *
2091            * @param groupId the group ID
2092            * @param mountPoint the mount point
2093            * @param parentFolderId the parent folder ID
2094            * @param hidden the hidden
2095            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2096            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
2097            */
2098            public DLFolder fetchByG_M_P_H_Last(long groupId, boolean mountPoint,
2099                    long parentFolderId, boolean hidden,
2100                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2101    
2102            /**
2103            * Returns the document library folders before and after the current document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2104            *
2105            * @param folderId the primary key of the current document library folder
2106            * @param groupId the group ID
2107            * @param mountPoint the mount point
2108            * @param parentFolderId the parent folder ID
2109            * @param hidden the hidden
2110            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2111            * @return the previous, current, and next document library folder
2112            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2113            */
2114            public DLFolder[] findByG_M_P_H_PrevAndNext(long folderId, long groupId,
2115                    boolean mountPoint, long parentFolderId, boolean hidden,
2116                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2117                    throws NoSuchFolderException;
2118    
2119            /**
2120            * Returns all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2121            *
2122            * @param groupId the group ID
2123            * @param mountPoint the mount point
2124            * @param parentFolderId the parent folder ID
2125            * @param hidden the hidden
2126            * @return the matching document library folders that the user has permission to view
2127            */
2128            public java.util.List<DLFolder> filterFindByG_M_P_H(long groupId,
2129                    boolean mountPoint, long parentFolderId, boolean hidden);
2130    
2131            /**
2132            * Returns a range of all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2133            *
2134            * <p>
2135            * 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 DLFolderModelImpl}. 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.
2136            * </p>
2137            *
2138            * @param groupId the group ID
2139            * @param mountPoint the mount point
2140            * @param parentFolderId the parent folder ID
2141            * @param hidden the hidden
2142            * @param start the lower bound of the range of document library folders
2143            * @param end the upper bound of the range of document library folders (not inclusive)
2144            * @return the range of matching document library folders that the user has permission to view
2145            */
2146            public java.util.List<DLFolder> filterFindByG_M_P_H(long groupId,
2147                    boolean mountPoint, long parentFolderId, boolean hidden, int start,
2148                    int end);
2149    
2150            /**
2151            * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2152            *
2153            * <p>
2154            * 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 DLFolderModelImpl}. 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.
2155            * </p>
2156            *
2157            * @param groupId the group ID
2158            * @param mountPoint the mount point
2159            * @param parentFolderId the parent folder ID
2160            * @param hidden the hidden
2161            * @param start the lower bound of the range of document library folders
2162            * @param end the upper bound of the range of document library folders (not inclusive)
2163            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2164            * @return the ordered range of matching document library folders that the user has permission to view
2165            */
2166            public java.util.List<DLFolder> filterFindByG_M_P_H(long groupId,
2167                    boolean mountPoint, long parentFolderId, boolean hidden, int start,
2168                    int end,
2169                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2170    
2171            /**
2172            * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2173            *
2174            * @param folderId the primary key of the current document library folder
2175            * @param groupId the group ID
2176            * @param mountPoint the mount point
2177            * @param parentFolderId the parent folder ID
2178            * @param hidden the hidden
2179            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2180            * @return the previous, current, and next document library folder
2181            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2182            */
2183            public DLFolder[] filterFindByG_M_P_H_PrevAndNext(long folderId,
2184                    long groupId, boolean mountPoint, long parentFolderId, boolean hidden,
2185                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2186                    throws NoSuchFolderException;
2187    
2188            /**
2189            * Removes all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; from the database.
2190            *
2191            * @param groupId the group ID
2192            * @param mountPoint the mount point
2193            * @param parentFolderId the parent folder ID
2194            * @param hidden the hidden
2195            */
2196            public void removeByG_M_P_H(long groupId, boolean mountPoint,
2197                    long parentFolderId, boolean hidden);
2198    
2199            /**
2200            * Returns the number of document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2201            *
2202            * @param groupId the group ID
2203            * @param mountPoint the mount point
2204            * @param parentFolderId the parent folder ID
2205            * @param hidden the hidden
2206            * @return the number of matching document library folders
2207            */
2208            public int countByG_M_P_H(long groupId, boolean mountPoint,
2209                    long parentFolderId, boolean hidden);
2210    
2211            /**
2212            * Returns the number of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63;.
2213            *
2214            * @param groupId the group ID
2215            * @param mountPoint the mount point
2216            * @param parentFolderId the parent folder ID
2217            * @param hidden the hidden
2218            * @return the number of matching document library folders that the user has permission to view
2219            */
2220            public int filterCountByG_M_P_H(long groupId, boolean mountPoint,
2221                    long parentFolderId, boolean hidden);
2222    
2223            /**
2224            * Returns all the document library folders where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2225            *
2226            * @param groupId the group ID
2227            * @param mountPoint the mount point
2228            * @param treePath the tree path
2229            * @param hidden the hidden
2230            * @return the matching document library folders
2231            */
2232            public java.util.List<DLFolder> findByG_M_T_H(long groupId,
2233                    boolean mountPoint, java.lang.String treePath, boolean hidden);
2234    
2235            /**
2236            * Returns a range of all the document library folders where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2237            *
2238            * <p>
2239            * 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 DLFolderModelImpl}. 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.
2240            * </p>
2241            *
2242            * @param groupId the group ID
2243            * @param mountPoint the mount point
2244            * @param treePath the tree path
2245            * @param hidden the hidden
2246            * @param start the lower bound of the range of document library folders
2247            * @param end the upper bound of the range of document library folders (not inclusive)
2248            * @return the range of matching document library folders
2249            */
2250            public java.util.List<DLFolder> findByG_M_T_H(long groupId,
2251                    boolean mountPoint, java.lang.String treePath, boolean hidden,
2252                    int start, int end);
2253    
2254            /**
2255            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2256            *
2257            * <p>
2258            * 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 DLFolderModelImpl}. 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.
2259            * </p>
2260            *
2261            * @param groupId the group ID
2262            * @param mountPoint the mount point
2263            * @param treePath the tree path
2264            * @param hidden the hidden
2265            * @param start the lower bound of the range of document library folders
2266            * @param end the upper bound of the range of document library folders (not inclusive)
2267            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2268            * @return the ordered range of matching document library folders
2269            */
2270            public java.util.List<DLFolder> findByG_M_T_H(long groupId,
2271                    boolean mountPoint, java.lang.String treePath, boolean hidden,
2272                    int start, int end,
2273                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2274    
2275            /**
2276            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2277            *
2278            * <p>
2279            * 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 DLFolderModelImpl}. 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.
2280            * </p>
2281            *
2282            * @param groupId the group ID
2283            * @param mountPoint the mount point
2284            * @param treePath the tree path
2285            * @param hidden the hidden
2286            * @param start the lower bound of the range of document library folders
2287            * @param end the upper bound of the range of document library folders (not inclusive)
2288            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2289            * @param retrieveFromCache whether to retrieve from the finder cache
2290            * @return the ordered range of matching document library folders
2291            */
2292            public java.util.List<DLFolder> findByG_M_T_H(long groupId,
2293                    boolean mountPoint, java.lang.String treePath, boolean hidden,
2294                    int start, int end,
2295                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
2296                    boolean retrieveFromCache);
2297    
2298            /**
2299            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2300            *
2301            * @param groupId the group ID
2302            * @param mountPoint the mount point
2303            * @param treePath the tree path
2304            * @param hidden the hidden
2305            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2306            * @return the first matching document library folder
2307            * @throws NoSuchFolderException if a matching document library folder could not be found
2308            */
2309            public DLFolder findByG_M_T_H_First(long groupId, boolean mountPoint,
2310                    java.lang.String treePath, boolean hidden,
2311                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2312                    throws NoSuchFolderException;
2313    
2314            /**
2315            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2316            *
2317            * @param groupId the group ID
2318            * @param mountPoint the mount point
2319            * @param treePath the tree path
2320            * @param hidden the hidden
2321            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2322            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
2323            */
2324            public DLFolder fetchByG_M_T_H_First(long groupId, boolean mountPoint,
2325                    java.lang.String treePath, boolean hidden,
2326                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2327    
2328            /**
2329            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2330            *
2331            * @param groupId the group ID
2332            * @param mountPoint the mount point
2333            * @param treePath the tree path
2334            * @param hidden the hidden
2335            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2336            * @return the last matching document library folder
2337            * @throws NoSuchFolderException if a matching document library folder could not be found
2338            */
2339            public DLFolder findByG_M_T_H_Last(long groupId, boolean mountPoint,
2340                    java.lang.String treePath, boolean hidden,
2341                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2342                    throws NoSuchFolderException;
2343    
2344            /**
2345            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2346            *
2347            * @param groupId the group ID
2348            * @param mountPoint the mount point
2349            * @param treePath the tree path
2350            * @param hidden the hidden
2351            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2352            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
2353            */
2354            public DLFolder fetchByG_M_T_H_Last(long groupId, boolean mountPoint,
2355                    java.lang.String treePath, boolean hidden,
2356                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2357    
2358            /**
2359            * Returns the document library folders before and after the current document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2360            *
2361            * @param folderId the primary key of the current document library folder
2362            * @param groupId the group ID
2363            * @param mountPoint the mount point
2364            * @param treePath the tree path
2365            * @param hidden the hidden
2366            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2367            * @return the previous, current, and next document library folder
2368            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2369            */
2370            public DLFolder[] findByG_M_T_H_PrevAndNext(long folderId, long groupId,
2371                    boolean mountPoint, java.lang.String treePath, boolean hidden,
2372                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2373                    throws NoSuchFolderException;
2374    
2375            /**
2376            * Returns all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2377            *
2378            * @param groupId the group ID
2379            * @param mountPoint the mount point
2380            * @param treePath the tree path
2381            * @param hidden the hidden
2382            * @return the matching document library folders that the user has permission to view
2383            */
2384            public java.util.List<DLFolder> filterFindByG_M_T_H(long groupId,
2385                    boolean mountPoint, java.lang.String treePath, boolean hidden);
2386    
2387            /**
2388            * Returns a range of all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2389            *
2390            * <p>
2391            * 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 DLFolderModelImpl}. 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.
2392            * </p>
2393            *
2394            * @param groupId the group ID
2395            * @param mountPoint the mount point
2396            * @param treePath the tree path
2397            * @param hidden the hidden
2398            * @param start the lower bound of the range of document library folders
2399            * @param end the upper bound of the range of document library folders (not inclusive)
2400            * @return the range of matching document library folders that the user has permission to view
2401            */
2402            public java.util.List<DLFolder> filterFindByG_M_T_H(long groupId,
2403                    boolean mountPoint, java.lang.String treePath, boolean hidden,
2404                    int start, int end);
2405    
2406            /**
2407            * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2408            *
2409            * <p>
2410            * 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 DLFolderModelImpl}. 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.
2411            * </p>
2412            *
2413            * @param groupId the group ID
2414            * @param mountPoint the mount point
2415            * @param treePath the tree path
2416            * @param hidden the hidden
2417            * @param start the lower bound of the range of document library folders
2418            * @param end the upper bound of the range of document library folders (not inclusive)
2419            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2420            * @return the ordered range of matching document library folders that the user has permission to view
2421            */
2422            public java.util.List<DLFolder> filterFindByG_M_T_H(long groupId,
2423                    boolean mountPoint, java.lang.String treePath, boolean hidden,
2424                    int start, int end,
2425                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2426    
2427            /**
2428            * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2429            *
2430            * @param folderId the primary key of the current document library folder
2431            * @param groupId the group ID
2432            * @param mountPoint the mount point
2433            * @param treePath the tree path
2434            * @param hidden the hidden
2435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2436            * @return the previous, current, and next document library folder
2437            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2438            */
2439            public DLFolder[] filterFindByG_M_T_H_PrevAndNext(long folderId,
2440                    long groupId, boolean mountPoint, java.lang.String treePath,
2441                    boolean hidden,
2442                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2443                    throws NoSuchFolderException;
2444    
2445            /**
2446            * Removes all the document library folders where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63; from the database.
2447            *
2448            * @param groupId the group ID
2449            * @param mountPoint the mount point
2450            * @param treePath the tree path
2451            * @param hidden the hidden
2452            */
2453            public void removeByG_M_T_H(long groupId, boolean mountPoint,
2454                    java.lang.String treePath, boolean hidden);
2455    
2456            /**
2457            * Returns the number of document library folders where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2458            *
2459            * @param groupId the group ID
2460            * @param mountPoint the mount point
2461            * @param treePath the tree path
2462            * @param hidden the hidden
2463            * @return the number of matching document library folders
2464            */
2465            public int countByG_M_T_H(long groupId, boolean mountPoint,
2466                    java.lang.String treePath, boolean hidden);
2467    
2468            /**
2469            * Returns the number of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and treePath LIKE &#63; and hidden = &#63;.
2470            *
2471            * @param groupId the group ID
2472            * @param mountPoint the mount point
2473            * @param treePath the tree path
2474            * @param hidden the hidden
2475            * @return the number of matching document library folders that the user has permission to view
2476            */
2477            public int filterCountByG_M_T_H(long groupId, boolean mountPoint,
2478                    java.lang.String treePath, boolean hidden);
2479    
2480            /**
2481            * Returns all the document library folders where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2482            *
2483            * @param groupId the group ID
2484            * @param parentFolderId the parent folder ID
2485            * @param hidden the hidden
2486            * @param status the status
2487            * @return the matching document library folders
2488            */
2489            public java.util.List<DLFolder> findByG_P_H_S(long groupId,
2490                    long parentFolderId, boolean hidden, int status);
2491    
2492            /**
2493            * Returns a range of all the document library folders where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2494            *
2495            * <p>
2496            * 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 DLFolderModelImpl}. 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.
2497            * </p>
2498            *
2499            * @param groupId the group ID
2500            * @param parentFolderId the parent folder ID
2501            * @param hidden the hidden
2502            * @param status the status
2503            * @param start the lower bound of the range of document library folders
2504            * @param end the upper bound of the range of document library folders (not inclusive)
2505            * @return the range of matching document library folders
2506            */
2507            public java.util.List<DLFolder> findByG_P_H_S(long groupId,
2508                    long parentFolderId, boolean hidden, int status, int start, int end);
2509    
2510            /**
2511            * Returns an ordered range of all the document library folders where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2512            *
2513            * <p>
2514            * 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 DLFolderModelImpl}. 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.
2515            * </p>
2516            *
2517            * @param groupId the group ID
2518            * @param parentFolderId the parent folder ID
2519            * @param hidden the hidden
2520            * @param status the status
2521            * @param start the lower bound of the range of document library folders
2522            * @param end the upper bound of the range of document library folders (not inclusive)
2523            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2524            * @return the ordered range of matching document library folders
2525            */
2526            public java.util.List<DLFolder> findByG_P_H_S(long groupId,
2527                    long parentFolderId, boolean hidden, int status, int start, int end,
2528                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2529    
2530            /**
2531            * Returns an ordered range of all the document library folders where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2532            *
2533            * <p>
2534            * 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 DLFolderModelImpl}. 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.
2535            * </p>
2536            *
2537            * @param groupId the group ID
2538            * @param parentFolderId the parent folder ID
2539            * @param hidden the hidden
2540            * @param status the status
2541            * @param start the lower bound of the range of document library folders
2542            * @param end the upper bound of the range of document library folders (not inclusive)
2543            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2544            * @param retrieveFromCache whether to retrieve from the finder cache
2545            * @return the ordered range of matching document library folders
2546            */
2547            public java.util.List<DLFolder> findByG_P_H_S(long groupId,
2548                    long parentFolderId, boolean hidden, int status, int start, int end,
2549                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
2550                    boolean retrieveFromCache);
2551    
2552            /**
2553            * Returns the first document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2554            *
2555            * @param groupId the group ID
2556            * @param parentFolderId the parent folder ID
2557            * @param hidden the hidden
2558            * @param status the status
2559            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2560            * @return the first matching document library folder
2561            * @throws NoSuchFolderException if a matching document library folder could not be found
2562            */
2563            public DLFolder findByG_P_H_S_First(long groupId, long parentFolderId,
2564                    boolean hidden, int status,
2565                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2566                    throws NoSuchFolderException;
2567    
2568            /**
2569            * Returns the first document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2570            *
2571            * @param groupId the group ID
2572            * @param parentFolderId the parent folder ID
2573            * @param hidden the hidden
2574            * @param status the status
2575            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2576            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
2577            */
2578            public DLFolder fetchByG_P_H_S_First(long groupId, long parentFolderId,
2579                    boolean hidden, int status,
2580                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2581    
2582            /**
2583            * Returns the last document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2584            *
2585            * @param groupId the group ID
2586            * @param parentFolderId the parent folder ID
2587            * @param hidden the hidden
2588            * @param status the status
2589            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2590            * @return the last matching document library folder
2591            * @throws NoSuchFolderException if a matching document library folder could not be found
2592            */
2593            public DLFolder findByG_P_H_S_Last(long groupId, long parentFolderId,
2594                    boolean hidden, int status,
2595                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2596                    throws NoSuchFolderException;
2597    
2598            /**
2599            * Returns the last document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2600            *
2601            * @param groupId the group ID
2602            * @param parentFolderId the parent folder ID
2603            * @param hidden the hidden
2604            * @param status the status
2605            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2606            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
2607            */
2608            public DLFolder fetchByG_P_H_S_Last(long groupId, long parentFolderId,
2609                    boolean hidden, int status,
2610                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2611    
2612            /**
2613            * Returns the document library folders before and after the current document library folder in the ordered set where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2614            *
2615            * @param folderId the primary key of the current document library folder
2616            * @param groupId the group ID
2617            * @param parentFolderId the parent folder ID
2618            * @param hidden the hidden
2619            * @param status the status
2620            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2621            * @return the previous, current, and next document library folder
2622            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2623            */
2624            public DLFolder[] findByG_P_H_S_PrevAndNext(long folderId, long groupId,
2625                    long parentFolderId, boolean hidden, int status,
2626                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2627                    throws NoSuchFolderException;
2628    
2629            /**
2630            * Returns all the document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2631            *
2632            * @param groupId the group ID
2633            * @param parentFolderId the parent folder ID
2634            * @param hidden the hidden
2635            * @param status the status
2636            * @return the matching document library folders that the user has permission to view
2637            */
2638            public java.util.List<DLFolder> filterFindByG_P_H_S(long groupId,
2639                    long parentFolderId, boolean hidden, int status);
2640    
2641            /**
2642            * Returns a range of all the document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2643            *
2644            * <p>
2645            * 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 DLFolderModelImpl}. 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.
2646            * </p>
2647            *
2648            * @param groupId the group ID
2649            * @param parentFolderId the parent folder ID
2650            * @param hidden the hidden
2651            * @param status the status
2652            * @param start the lower bound of the range of document library folders
2653            * @param end the upper bound of the range of document library folders (not inclusive)
2654            * @return the range of matching document library folders that the user has permission to view
2655            */
2656            public java.util.List<DLFolder> filterFindByG_P_H_S(long groupId,
2657                    long parentFolderId, boolean hidden, int status, int start, int end);
2658    
2659            /**
2660            * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2661            *
2662            * <p>
2663            * 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 DLFolderModelImpl}. 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.
2664            * </p>
2665            *
2666            * @param groupId the group ID
2667            * @param parentFolderId the parent folder ID
2668            * @param hidden the hidden
2669            * @param status the status
2670            * @param start the lower bound of the range of document library folders
2671            * @param end the upper bound of the range of document library folders (not inclusive)
2672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2673            * @return the ordered range of matching document library folders that the user has permission to view
2674            */
2675            public java.util.List<DLFolder> filterFindByG_P_H_S(long groupId,
2676                    long parentFolderId, boolean hidden, int status, int start, int end,
2677                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2678    
2679            /**
2680            * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2681            *
2682            * @param folderId the primary key of the current document library folder
2683            * @param groupId the group ID
2684            * @param parentFolderId the parent folder ID
2685            * @param hidden the hidden
2686            * @param status the status
2687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2688            * @return the previous, current, and next document library folder
2689            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2690            */
2691            public DLFolder[] filterFindByG_P_H_S_PrevAndNext(long folderId,
2692                    long groupId, long parentFolderId, boolean hidden, int status,
2693                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2694                    throws NoSuchFolderException;
2695    
2696            /**
2697            * Removes all the document library folders where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63; from the database.
2698            *
2699            * @param groupId the group ID
2700            * @param parentFolderId the parent folder ID
2701            * @param hidden the hidden
2702            * @param status the status
2703            */
2704            public void removeByG_P_H_S(long groupId, long parentFolderId,
2705                    boolean hidden, int status);
2706    
2707            /**
2708            * Returns the number of document library folders where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2709            *
2710            * @param groupId the group ID
2711            * @param parentFolderId the parent folder ID
2712            * @param hidden the hidden
2713            * @param status the status
2714            * @return the number of matching document library folders
2715            */
2716            public int countByG_P_H_S(long groupId, long parentFolderId,
2717                    boolean hidden, int status);
2718    
2719            /**
2720            * Returns the number of document library folders that the user has permission to view where groupId = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2721            *
2722            * @param groupId the group ID
2723            * @param parentFolderId the parent folder ID
2724            * @param hidden the hidden
2725            * @param status the status
2726            * @return the number of matching document library folders that the user has permission to view
2727            */
2728            public int filterCountByG_P_H_S(long groupId, long parentFolderId,
2729                    boolean hidden, int status);
2730    
2731            /**
2732            * Returns all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2733            *
2734            * @param groupId the group ID
2735            * @param mountPoint the mount point
2736            * @param parentFolderId the parent folder ID
2737            * @param hidden the hidden
2738            * @param status the status
2739            * @return the matching document library folders
2740            */
2741            public java.util.List<DLFolder> findByG_M_P_H_S(long groupId,
2742                    boolean mountPoint, long parentFolderId, boolean hidden, int status);
2743    
2744            /**
2745            * Returns a range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2746            *
2747            * <p>
2748            * 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 DLFolderModelImpl}. 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.
2749            * </p>
2750            *
2751            * @param groupId the group ID
2752            * @param mountPoint the mount point
2753            * @param parentFolderId the parent folder ID
2754            * @param hidden the hidden
2755            * @param status the status
2756            * @param start the lower bound of the range of document library folders
2757            * @param end the upper bound of the range of document library folders (not inclusive)
2758            * @return the range of matching document library folders
2759            */
2760            public java.util.List<DLFolder> findByG_M_P_H_S(long groupId,
2761                    boolean mountPoint, long parentFolderId, boolean hidden, int status,
2762                    int start, int end);
2763    
2764            /**
2765            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2766            *
2767            * <p>
2768            * 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 DLFolderModelImpl}. 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.
2769            * </p>
2770            *
2771            * @param groupId the group ID
2772            * @param mountPoint the mount point
2773            * @param parentFolderId the parent folder ID
2774            * @param hidden the hidden
2775            * @param status the status
2776            * @param start the lower bound of the range of document library folders
2777            * @param end the upper bound of the range of document library folders (not inclusive)
2778            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2779            * @return the ordered range of matching document library folders
2780            */
2781            public java.util.List<DLFolder> findByG_M_P_H_S(long groupId,
2782                    boolean mountPoint, long parentFolderId, boolean hidden, int status,
2783                    int start, int end,
2784                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2785    
2786            /**
2787            * Returns an ordered range of all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2788            *
2789            * <p>
2790            * 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 DLFolderModelImpl}. 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.
2791            * </p>
2792            *
2793            * @param groupId the group ID
2794            * @param mountPoint the mount point
2795            * @param parentFolderId the parent folder ID
2796            * @param hidden the hidden
2797            * @param status the status
2798            * @param start the lower bound of the range of document library folders
2799            * @param end the upper bound of the range of document library folders (not inclusive)
2800            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2801            * @param retrieveFromCache whether to retrieve from the finder cache
2802            * @return the ordered range of matching document library folders
2803            */
2804            public java.util.List<DLFolder> findByG_M_P_H_S(long groupId,
2805                    boolean mountPoint, long parentFolderId, boolean hidden, int status,
2806                    int start, int end,
2807                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
2808                    boolean retrieveFromCache);
2809    
2810            /**
2811            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2812            *
2813            * @param groupId the group ID
2814            * @param mountPoint the mount point
2815            * @param parentFolderId the parent folder ID
2816            * @param hidden the hidden
2817            * @param status the status
2818            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2819            * @return the first matching document library folder
2820            * @throws NoSuchFolderException if a matching document library folder could not be found
2821            */
2822            public DLFolder findByG_M_P_H_S_First(long groupId, boolean mountPoint,
2823                    long parentFolderId, boolean hidden, int status,
2824                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2825                    throws NoSuchFolderException;
2826    
2827            /**
2828            * Returns the first document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2829            *
2830            * @param groupId the group ID
2831            * @param mountPoint the mount point
2832            * @param parentFolderId the parent folder ID
2833            * @param hidden the hidden
2834            * @param status the status
2835            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2836            * @return the first matching document library folder, or <code>null</code> if a matching document library folder could not be found
2837            */
2838            public DLFolder fetchByG_M_P_H_S_First(long groupId, boolean mountPoint,
2839                    long parentFolderId, boolean hidden, int status,
2840                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2841    
2842            /**
2843            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2844            *
2845            * @param groupId the group ID
2846            * @param mountPoint the mount point
2847            * @param parentFolderId the parent folder ID
2848            * @param hidden the hidden
2849            * @param status the status
2850            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2851            * @return the last matching document library folder
2852            * @throws NoSuchFolderException if a matching document library folder could not be found
2853            */
2854            public DLFolder findByG_M_P_H_S_Last(long groupId, boolean mountPoint,
2855                    long parentFolderId, boolean hidden, int status,
2856                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2857                    throws NoSuchFolderException;
2858    
2859            /**
2860            * Returns the last document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2861            *
2862            * @param groupId the group ID
2863            * @param mountPoint the mount point
2864            * @param parentFolderId the parent folder ID
2865            * @param hidden the hidden
2866            * @param status the status
2867            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2868            * @return the last matching document library folder, or <code>null</code> if a matching document library folder could not be found
2869            */
2870            public DLFolder fetchByG_M_P_H_S_Last(long groupId, boolean mountPoint,
2871                    long parentFolderId, boolean hidden, int status,
2872                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2873    
2874            /**
2875            * Returns the document library folders before and after the current document library folder in the ordered set where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2876            *
2877            * @param folderId the primary key of the current document library folder
2878            * @param groupId the group ID
2879            * @param mountPoint the mount point
2880            * @param parentFolderId the parent folder ID
2881            * @param hidden the hidden
2882            * @param status the status
2883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2884            * @return the previous, current, and next document library folder
2885            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2886            */
2887            public DLFolder[] findByG_M_P_H_S_PrevAndNext(long folderId, long groupId,
2888                    boolean mountPoint, long parentFolderId, boolean hidden, int status,
2889                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2890                    throws NoSuchFolderException;
2891    
2892            /**
2893            * Returns all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2894            *
2895            * @param groupId the group ID
2896            * @param mountPoint the mount point
2897            * @param parentFolderId the parent folder ID
2898            * @param hidden the hidden
2899            * @param status the status
2900            * @return the matching document library folders that the user has permission to view
2901            */
2902            public java.util.List<DLFolder> filterFindByG_M_P_H_S(long groupId,
2903                    boolean mountPoint, long parentFolderId, boolean hidden, int status);
2904    
2905            /**
2906            * Returns a range of all the document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2907            *
2908            * <p>
2909            * 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 DLFolderModelImpl}. 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.
2910            * </p>
2911            *
2912            * @param groupId the group ID
2913            * @param mountPoint the mount point
2914            * @param parentFolderId the parent folder ID
2915            * @param hidden the hidden
2916            * @param status the status
2917            * @param start the lower bound of the range of document library folders
2918            * @param end the upper bound of the range of document library folders (not inclusive)
2919            * @return the range of matching document library folders that the user has permission to view
2920            */
2921            public java.util.List<DLFolder> filterFindByG_M_P_H_S(long groupId,
2922                    boolean mountPoint, long parentFolderId, boolean hidden, int status,
2923                    int start, int end);
2924    
2925            /**
2926            * Returns an ordered range of all the document library folders that the user has permissions to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2927            *
2928            * <p>
2929            * 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 DLFolderModelImpl}. 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.
2930            * </p>
2931            *
2932            * @param groupId the group ID
2933            * @param mountPoint the mount point
2934            * @param parentFolderId the parent folder ID
2935            * @param hidden the hidden
2936            * @param status the status
2937            * @param start the lower bound of the range of document library folders
2938            * @param end the upper bound of the range of document library folders (not inclusive)
2939            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2940            * @return the ordered range of matching document library folders that the user has permission to view
2941            */
2942            public java.util.List<DLFolder> filterFindByG_M_P_H_S(long groupId,
2943                    boolean mountPoint, long parentFolderId, boolean hidden, int status,
2944                    int start, int end,
2945                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
2946    
2947            /**
2948            * Returns the document library folders before and after the current document library folder in the ordered set of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2949            *
2950            * @param folderId the primary key of the current document library folder
2951            * @param groupId the group ID
2952            * @param mountPoint the mount point
2953            * @param parentFolderId the parent folder ID
2954            * @param hidden the hidden
2955            * @param status the status
2956            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2957            * @return the previous, current, and next document library folder
2958            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
2959            */
2960            public DLFolder[] filterFindByG_M_P_H_S_PrevAndNext(long folderId,
2961                    long groupId, boolean mountPoint, long parentFolderId, boolean hidden,
2962                    int status,
2963                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator)
2964                    throws NoSuchFolderException;
2965    
2966            /**
2967            * Removes all the document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63; from the database.
2968            *
2969            * @param groupId the group ID
2970            * @param mountPoint the mount point
2971            * @param parentFolderId the parent folder ID
2972            * @param hidden the hidden
2973            * @param status the status
2974            */
2975            public void removeByG_M_P_H_S(long groupId, boolean mountPoint,
2976                    long parentFolderId, boolean hidden, int status);
2977    
2978            /**
2979            * Returns the number of document library folders where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2980            *
2981            * @param groupId the group ID
2982            * @param mountPoint the mount point
2983            * @param parentFolderId the parent folder ID
2984            * @param hidden the hidden
2985            * @param status the status
2986            * @return the number of matching document library folders
2987            */
2988            public int countByG_M_P_H_S(long groupId, boolean mountPoint,
2989                    long parentFolderId, boolean hidden, int status);
2990    
2991            /**
2992            * Returns the number of document library folders that the user has permission to view where groupId = &#63; and mountPoint = &#63; and parentFolderId = &#63; and hidden = &#63; and status = &#63;.
2993            *
2994            * @param groupId the group ID
2995            * @param mountPoint the mount point
2996            * @param parentFolderId the parent folder ID
2997            * @param hidden the hidden
2998            * @param status the status
2999            * @return the number of matching document library folders that the user has permission to view
3000            */
3001            public int filterCountByG_M_P_H_S(long groupId, boolean mountPoint,
3002                    long parentFolderId, boolean hidden, int status);
3003    
3004            /**
3005            * Caches the document library folder in the entity cache if it is enabled.
3006            *
3007            * @param dlFolder the document library folder
3008            */
3009            public void cacheResult(DLFolder dlFolder);
3010    
3011            /**
3012            * Caches the document library folders in the entity cache if it is enabled.
3013            *
3014            * @param dlFolders the document library folders
3015            */
3016            public void cacheResult(java.util.List<DLFolder> dlFolders);
3017    
3018            /**
3019            * Creates a new document library folder with the primary key. Does not add the document library folder to the database.
3020            *
3021            * @param folderId the primary key for the new document library folder
3022            * @return the new document library folder
3023            */
3024            public DLFolder create(long folderId);
3025    
3026            /**
3027            * Removes the document library folder with the primary key from the database. Also notifies the appropriate model listeners.
3028            *
3029            * @param folderId the primary key of the document library folder
3030            * @return the document library folder that was removed
3031            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
3032            */
3033            public DLFolder remove(long folderId) throws NoSuchFolderException;
3034    
3035            public DLFolder updateImpl(DLFolder dlFolder);
3036    
3037            /**
3038            * Returns the document library folder with the primary key or throws a {@link NoSuchFolderException} if it could not be found.
3039            *
3040            * @param folderId the primary key of the document library folder
3041            * @return the document library folder
3042            * @throws NoSuchFolderException if a document library folder with the primary key could not be found
3043            */
3044            public DLFolder findByPrimaryKey(long folderId)
3045                    throws NoSuchFolderException;
3046    
3047            /**
3048            * Returns the document library folder with the primary key or returns <code>null</code> if it could not be found.
3049            *
3050            * @param folderId the primary key of the document library folder
3051            * @return the document library folder, or <code>null</code> if a document library folder with the primary key could not be found
3052            */
3053            public DLFolder fetchByPrimaryKey(long folderId);
3054    
3055            @Override
3056            public java.util.Map<java.io.Serializable, DLFolder> fetchByPrimaryKeys(
3057                    java.util.Set<java.io.Serializable> primaryKeys);
3058    
3059            /**
3060            * Returns all the document library folders.
3061            *
3062            * @return the document library folders
3063            */
3064            public java.util.List<DLFolder> findAll();
3065    
3066            /**
3067            * Returns a range of all the document library folders.
3068            *
3069            * <p>
3070            * 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 DLFolderModelImpl}. 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.
3071            * </p>
3072            *
3073            * @param start the lower bound of the range of document library folders
3074            * @param end the upper bound of the range of document library folders (not inclusive)
3075            * @return the range of document library folders
3076            */
3077            public java.util.List<DLFolder> findAll(int start, int end);
3078    
3079            /**
3080            * Returns an ordered range of all the document library folders.
3081            *
3082            * <p>
3083            * 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 DLFolderModelImpl}. 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.
3084            * </p>
3085            *
3086            * @param start the lower bound of the range of document library folders
3087            * @param end the upper bound of the range of document library folders (not inclusive)
3088            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3089            * @return the ordered range of document library folders
3090            */
3091            public java.util.List<DLFolder> findAll(int start, int end,
3092                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator);
3093    
3094            /**
3095            * Returns an ordered range of all the document library folders.
3096            *
3097            * <p>
3098            * 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 DLFolderModelImpl}. 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.
3099            * </p>
3100            *
3101            * @param start the lower bound of the range of document library folders
3102            * @param end the upper bound of the range of document library folders (not inclusive)
3103            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3104            * @param retrieveFromCache whether to retrieve from the finder cache
3105            * @return the ordered range of document library folders
3106            */
3107            public java.util.List<DLFolder> findAll(int start, int end,
3108                    com.liferay.portal.kernel.util.OrderByComparator<DLFolder> orderByComparator,
3109                    boolean retrieveFromCache);
3110    
3111            /**
3112            * Removes all the document library folders from the database.
3113            */
3114            public void removeAll();
3115    
3116            /**
3117            * Returns the number of document library folders.
3118            *
3119            * @return the number of document library folders
3120            */
3121            public int countAll();
3122    
3123            /**
3124            * Returns the primaryKeys of document library file entry types associated with the document library folder.
3125            *
3126            * @param pk the primary key of the document library folder
3127            * @return long[] of the primaryKeys of document library file entry types associated with the document library folder
3128            */
3129            public long[] getDLFileEntryTypePrimaryKeys(long pk);
3130    
3131            /**
3132            * Returns all the document library file entry types associated with the document library folder.
3133            *
3134            * @param pk the primary key of the document library folder
3135            * @return the document library file entry types associated with the document library folder
3136            */
3137            public java.util.List<com.liferay.document.library.kernel.model.DLFileEntryType> getDLFileEntryTypes(
3138                    long pk);
3139    
3140            /**
3141            * Returns a range of all the document library file entry types associated with the document library folder.
3142            *
3143            * <p>
3144            * 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 DLFolderModelImpl}. 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.
3145            * </p>
3146            *
3147            * @param pk the primary key of the document library folder
3148            * @param start the lower bound of the range of document library folders
3149            * @param end the upper bound of the range of document library folders (not inclusive)
3150            * @return the range of document library file entry types associated with the document library folder
3151            */
3152            public java.util.List<com.liferay.document.library.kernel.model.DLFileEntryType> getDLFileEntryTypes(
3153                    long pk, int start, int end);
3154    
3155            /**
3156            * Returns an ordered range of all the document library file entry types associated with the document library folder.
3157            *
3158            * <p>
3159            * 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 DLFolderModelImpl}. 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.
3160            * </p>
3161            *
3162            * @param pk the primary key of the document library folder
3163            * @param start the lower bound of the range of document library folders
3164            * @param end the upper bound of the range of document library folders (not inclusive)
3165            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3166            * @return the ordered range of document library file entry types associated with the document library folder
3167            */
3168            public java.util.List<com.liferay.document.library.kernel.model.DLFileEntryType> getDLFileEntryTypes(
3169                    long pk, int start, int end,
3170                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.document.library.kernel.model.DLFileEntryType> orderByComparator);
3171    
3172            /**
3173            * Returns the number of document library file entry types associated with the document library folder.
3174            *
3175            * @param pk the primary key of the document library folder
3176            * @return the number of document library file entry types associated with the document library folder
3177            */
3178            public int getDLFileEntryTypesSize(long pk);
3179    
3180            /**
3181            * Returns <code>true</code> if the document library file entry type is associated with the document library folder.
3182            *
3183            * @param pk the primary key of the document library folder
3184            * @param dlFileEntryTypePK the primary key of the document library file entry type
3185            * @return <code>true</code> if the document library file entry type is associated with the document library folder; <code>false</code> otherwise
3186            */
3187            public boolean containsDLFileEntryType(long pk, long dlFileEntryTypePK);
3188    
3189            /**
3190            * Returns <code>true</code> if the document library folder has any document library file entry types associated with it.
3191            *
3192            * @param pk the primary key of the document library folder to check for associations with document library file entry types
3193            * @return <code>true</code> if the document library folder has any document library file entry types associated with it; <code>false</code> otherwise
3194            */
3195            public boolean containsDLFileEntryTypes(long pk);
3196    
3197            /**
3198            * Adds an association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3199            *
3200            * @param pk the primary key of the document library folder
3201            * @param dlFileEntryTypePK the primary key of the document library file entry type
3202            */
3203            public void addDLFileEntryType(long pk, long dlFileEntryTypePK);
3204    
3205            /**
3206            * Adds an association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3207            *
3208            * @param pk the primary key of the document library folder
3209            * @param dlFileEntryType the document library file entry type
3210            */
3211            public void addDLFileEntryType(long pk,
3212                    com.liferay.document.library.kernel.model.DLFileEntryType dlFileEntryType);
3213    
3214            /**
3215            * Adds an association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3216            *
3217            * @param pk the primary key of the document library folder
3218            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
3219            */
3220            public void addDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs);
3221    
3222            /**
3223            * Adds an association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3224            *
3225            * @param pk the primary key of the document library folder
3226            * @param dlFileEntryTypes the document library file entry types
3227            */
3228            public void addDLFileEntryTypes(long pk,
3229                    java.util.List<com.liferay.document.library.kernel.model.DLFileEntryType> dlFileEntryTypes);
3230    
3231            /**
3232            * Clears all associations between the document library folder and its document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3233            *
3234            * @param pk the primary key of the document library folder to clear the associated document library file entry types from
3235            */
3236            public void clearDLFileEntryTypes(long pk);
3237    
3238            /**
3239            * Removes the association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3240            *
3241            * @param pk the primary key of the document library folder
3242            * @param dlFileEntryTypePK the primary key of the document library file entry type
3243            */
3244            public void removeDLFileEntryType(long pk, long dlFileEntryTypePK);
3245    
3246            /**
3247            * Removes the association between the document library folder and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3248            *
3249            * @param pk the primary key of the document library folder
3250            * @param dlFileEntryType the document library file entry type
3251            */
3252            public void removeDLFileEntryType(long pk,
3253                    com.liferay.document.library.kernel.model.DLFileEntryType dlFileEntryType);
3254    
3255            /**
3256            * Removes the association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3257            *
3258            * @param pk the primary key of the document library folder
3259            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
3260            */
3261            public void removeDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs);
3262    
3263            /**
3264            * Removes the association between the document library folder and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3265            *
3266            * @param pk the primary key of the document library folder
3267            * @param dlFileEntryTypes the document library file entry types
3268            */
3269            public void removeDLFileEntryTypes(long pk,
3270                    java.util.List<com.liferay.document.library.kernel.model.DLFileEntryType> dlFileEntryTypes);
3271    
3272            /**
3273            * Sets the document library file entry types associated with the document library folder, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3274            *
3275            * @param pk the primary key of the document library folder
3276            * @param dlFileEntryTypePKs the primary keys of the document library file entry types to be associated with the document library folder
3277            */
3278            public void setDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs);
3279    
3280            /**
3281            * Sets the document library file entry types associated with the document library folder, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3282            *
3283            * @param pk the primary key of the document library folder
3284            * @param dlFileEntryTypes the document library file entry types to be associated with the document library folder
3285            */
3286            public void setDLFileEntryTypes(long pk,
3287                    java.util.List<com.liferay.document.library.kernel.model.DLFileEntryType> dlFileEntryTypes);
3288    
3289            @Override
3290            public java.util.Set<java.lang.String> getBadColumnNames();
3291    }