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