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