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