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