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