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