001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.document.library.kernel.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.document.library.kernel.exception.NoSuchFileVersionException;
020    import com.liferay.document.library.kernel.model.DLFileVersion;
021    
022    import com.liferay.portal.kernel.service.persistence.BasePersistence;
023    
024    /**
025     * The persistence interface for the document library file version service.
026     *
027     * <p>
028     * Caching information and settings can be found in <code>portal.properties</code>
029     * </p>
030     *
031     * @author Brian Wing Shun Chan
032     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl
033     * @see DLFileVersionUtil
034     * @generated
035     */
036    @ProviderType
037    public interface DLFileVersionPersistence extends BasePersistence<DLFileVersion> {
038            /*
039             * NOTE FOR DEVELOPERS:
040             *
041             * Never modify or reference this interface directly. Always use {@link DLFileVersionUtil} to access the document library file version persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
042             */
043    
044            /**
045            * Returns all the document library file versions where uuid = &#63;.
046            *
047            * @param uuid the uuid
048            * @return the matching document library file versions
049            */
050            public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid);
051    
052            /**
053            * Returns a range of all the document library file versions where uuid = &#63;.
054            *
055            * <p>
056            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
057            * </p>
058            *
059            * @param uuid the uuid
060            * @param start the lower bound of the range of document library file versions
061            * @param end the upper bound of the range of document library file versions (not inclusive)
062            * @return the range of matching document library file versions
063            */
064            public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid,
065                    int start, int end);
066    
067            /**
068            * Returns an ordered range of all the document library file versions where uuid = &#63;.
069            *
070            * <p>
071            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
072            * </p>
073            *
074            * @param uuid the uuid
075            * @param start the lower bound of the range of document library file versions
076            * @param end the upper bound of the range of document library file versions (not inclusive)
077            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
078            * @return the ordered range of matching document library file versions
079            */
080            public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid,
081                    int start, int end,
082                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
083    
084            /**
085            * Returns an ordered range of all the document library file versions where uuid = &#63;.
086            *
087            * <p>
088            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
089            * </p>
090            *
091            * @param uuid the uuid
092            * @param start the lower bound of the range of document library file versions
093            * @param end the upper bound of the range of document library file versions (not inclusive)
094            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
095            * @param retrieveFromCache whether to retrieve from the finder cache
096            * @return the ordered range of matching document library file versions
097            */
098            public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid,
099                    int start, int end,
100                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
101                    boolean retrieveFromCache);
102    
103            /**
104            * Returns the first document library file version in the ordered set where uuid = &#63;.
105            *
106            * @param uuid the uuid
107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
108            * @return the first matching document library file version
109            * @throws NoSuchFileVersionException if a matching document library file version could not be found
110            */
111            public DLFileVersion findByUuid_First(java.lang.String uuid,
112                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
113                    throws NoSuchFileVersionException;
114    
115            /**
116            * Returns the first document library file version in the ordered set where uuid = &#63;.
117            *
118            * @param uuid the uuid
119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
120            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
121            */
122            public DLFileVersion fetchByUuid_First(java.lang.String uuid,
123                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
124    
125            /**
126            * Returns the last document library file version in the ordered set where uuid = &#63;.
127            *
128            * @param uuid the uuid
129            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
130            * @return the last matching document library file version
131            * @throws NoSuchFileVersionException if a matching document library file version could not be found
132            */
133            public DLFileVersion findByUuid_Last(java.lang.String uuid,
134                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
135                    throws NoSuchFileVersionException;
136    
137            /**
138            * Returns the last document library file version in the ordered set where uuid = &#63;.
139            *
140            * @param uuid the uuid
141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
142            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
143            */
144            public DLFileVersion fetchByUuid_Last(java.lang.String uuid,
145                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
146    
147            /**
148            * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = &#63;.
149            *
150            * @param fileVersionId the primary key of the current document library file version
151            * @param uuid the uuid
152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
153            * @return the previous, current, and next document library file version
154            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
155            */
156            public DLFileVersion[] findByUuid_PrevAndNext(long fileVersionId,
157                    java.lang.String uuid,
158                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
159                    throws NoSuchFileVersionException;
160    
161            /**
162            * Removes all the document library file versions where uuid = &#63; from the database.
163            *
164            * @param uuid the uuid
165            */
166            public void removeByUuid(java.lang.String uuid);
167    
168            /**
169            * Returns the number of document library file versions where uuid = &#63;.
170            *
171            * @param uuid the uuid
172            * @return the number of matching document library file versions
173            */
174            public int countByUuid(java.lang.String uuid);
175    
176            /**
177            * Returns the document library file version where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFileVersionException} if it could not be found.
178            *
179            * @param uuid the uuid
180            * @param groupId the group ID
181            * @return the matching document library file version
182            * @throws NoSuchFileVersionException if a matching document library file version could not be found
183            */
184            public DLFileVersion findByUUID_G(java.lang.String uuid, long groupId)
185                    throws NoSuchFileVersionException;
186    
187            /**
188            * Returns the document library file version where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
189            *
190            * @param uuid the uuid
191            * @param groupId the group ID
192            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
193            */
194            public DLFileVersion fetchByUUID_G(java.lang.String uuid, long groupId);
195    
196            /**
197            * Returns the document library file version where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
198            *
199            * @param uuid the uuid
200            * @param groupId the group ID
201            * @param retrieveFromCache whether to retrieve from the finder cache
202            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
203            */
204            public DLFileVersion fetchByUUID_G(java.lang.String uuid, long groupId,
205                    boolean retrieveFromCache);
206    
207            /**
208            * Removes the document library file version where uuid = &#63; and groupId = &#63; from the database.
209            *
210            * @param uuid the uuid
211            * @param groupId the group ID
212            * @return the document library file version that was removed
213            */
214            public DLFileVersion removeByUUID_G(java.lang.String uuid, long groupId)
215                    throws NoSuchFileVersionException;
216    
217            /**
218            * Returns the number of document library file versions where uuid = &#63; and groupId = &#63;.
219            *
220            * @param uuid the uuid
221            * @param groupId the group ID
222            * @return the number of matching document library file versions
223            */
224            public int countByUUID_G(java.lang.String uuid, long groupId);
225    
226            /**
227            * Returns all the document library file versions where uuid = &#63; and companyId = &#63;.
228            *
229            * @param uuid the uuid
230            * @param companyId the company ID
231            * @return the matching document library file versions
232            */
233            public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid,
234                    long companyId);
235    
236            /**
237            * Returns a range of all the document library file versions where uuid = &#63; and companyId = &#63;.
238            *
239            * <p>
240            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
241            * </p>
242            *
243            * @param uuid the uuid
244            * @param companyId the company ID
245            * @param start the lower bound of the range of document library file versions
246            * @param end the upper bound of the range of document library file versions (not inclusive)
247            * @return the range of matching document library file versions
248            */
249            public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid,
250                    long companyId, int start, int end);
251    
252            /**
253            * Returns an ordered range of all the document library file versions where uuid = &#63; and companyId = &#63;.
254            *
255            * <p>
256            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
257            * </p>
258            *
259            * @param uuid the uuid
260            * @param companyId the company ID
261            * @param start the lower bound of the range of document library file versions
262            * @param end the upper bound of the range of document library file versions (not inclusive)
263            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
264            * @return the ordered range of matching document library file versions
265            */
266            public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid,
267                    long companyId, int start, int end,
268                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
269    
270            /**
271            * Returns an ordered range of all the document library file versions where uuid = &#63; and companyId = &#63;.
272            *
273            * <p>
274            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
275            * </p>
276            *
277            * @param uuid the uuid
278            * @param companyId the company ID
279            * @param start the lower bound of the range of document library file versions
280            * @param end the upper bound of the range of document library file versions (not inclusive)
281            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
282            * @param retrieveFromCache whether to retrieve from the finder cache
283            * @return the ordered range of matching document library file versions
284            */
285            public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid,
286                    long companyId, int start, int end,
287                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
288                    boolean retrieveFromCache);
289    
290            /**
291            * Returns the first document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
292            *
293            * @param uuid the uuid
294            * @param companyId the company ID
295            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
296            * @return the first matching document library file version
297            * @throws NoSuchFileVersionException if a matching document library file version could not be found
298            */
299            public DLFileVersion findByUuid_C_First(java.lang.String uuid,
300                    long companyId,
301                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
302                    throws NoSuchFileVersionException;
303    
304            /**
305            * Returns the first document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
306            *
307            * @param uuid the uuid
308            * @param companyId the company ID
309            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
310            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
311            */
312            public DLFileVersion fetchByUuid_C_First(java.lang.String uuid,
313                    long companyId,
314                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
315    
316            /**
317            * Returns the last document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
318            *
319            * @param uuid the uuid
320            * @param companyId the company ID
321            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
322            * @return the last matching document library file version
323            * @throws NoSuchFileVersionException if a matching document library file version could not be found
324            */
325            public DLFileVersion findByUuid_C_Last(java.lang.String uuid,
326                    long companyId,
327                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
328                    throws NoSuchFileVersionException;
329    
330            /**
331            * Returns the last document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
332            *
333            * @param uuid the uuid
334            * @param companyId the company ID
335            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
336            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
337            */
338            public DLFileVersion fetchByUuid_C_Last(java.lang.String uuid,
339                    long companyId,
340                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
341    
342            /**
343            * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
344            *
345            * @param fileVersionId the primary key of the current document library file version
346            * @param uuid the uuid
347            * @param companyId the company ID
348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
349            * @return the previous, current, and next document library file version
350            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
351            */
352            public DLFileVersion[] findByUuid_C_PrevAndNext(long fileVersionId,
353                    java.lang.String uuid, long companyId,
354                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
355                    throws NoSuchFileVersionException;
356    
357            /**
358            * Removes all the document library file versions where uuid = &#63; and companyId = &#63; from the database.
359            *
360            * @param uuid the uuid
361            * @param companyId the company ID
362            */
363            public void removeByUuid_C(java.lang.String uuid, long companyId);
364    
365            /**
366            * Returns the number of document library file versions where uuid = &#63; and companyId = &#63;.
367            *
368            * @param uuid the uuid
369            * @param companyId the company ID
370            * @return the number of matching document library file versions
371            */
372            public int countByUuid_C(java.lang.String uuid, long companyId);
373    
374            /**
375            * Returns all the document library file versions where companyId = &#63;.
376            *
377            * @param companyId the company ID
378            * @return the matching document library file versions
379            */
380            public java.util.List<DLFileVersion> findByCompanyId(long companyId);
381    
382            /**
383            * Returns a range of all the document library file versions where companyId = &#63;.
384            *
385            * <p>
386            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
387            * </p>
388            *
389            * @param companyId the company ID
390            * @param start the lower bound of the range of document library file versions
391            * @param end the upper bound of the range of document library file versions (not inclusive)
392            * @return the range of matching document library file versions
393            */
394            public java.util.List<DLFileVersion> findByCompanyId(long companyId,
395                    int start, int end);
396    
397            /**
398            * Returns an ordered range of all the document library file versions where companyId = &#63;.
399            *
400            * <p>
401            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
402            * </p>
403            *
404            * @param companyId the company ID
405            * @param start the lower bound of the range of document library file versions
406            * @param end the upper bound of the range of document library file versions (not inclusive)
407            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
408            * @return the ordered range of matching document library file versions
409            */
410            public java.util.List<DLFileVersion> findByCompanyId(long companyId,
411                    int start, int end,
412                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
413    
414            /**
415            * Returns an ordered range of all the document library file versions where companyId = &#63;.
416            *
417            * <p>
418            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
419            * </p>
420            *
421            * @param companyId the company ID
422            * @param start the lower bound of the range of document library file versions
423            * @param end the upper bound of the range of document library file versions (not inclusive)
424            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
425            * @param retrieveFromCache whether to retrieve from the finder cache
426            * @return the ordered range of matching document library file versions
427            */
428            public java.util.List<DLFileVersion> findByCompanyId(long companyId,
429                    int start, int end,
430                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
431                    boolean retrieveFromCache);
432    
433            /**
434            * Returns the first document library file version in the ordered set where companyId = &#63;.
435            *
436            * @param companyId the company ID
437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
438            * @return the first matching document library file version
439            * @throws NoSuchFileVersionException if a matching document library file version could not be found
440            */
441            public DLFileVersion findByCompanyId_First(long companyId,
442                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
443                    throws NoSuchFileVersionException;
444    
445            /**
446            * Returns the first document library file version in the ordered set where companyId = &#63;.
447            *
448            * @param companyId the company ID
449            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
450            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
451            */
452            public DLFileVersion fetchByCompanyId_First(long companyId,
453                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
454    
455            /**
456            * Returns the last document library file version in the ordered set where companyId = &#63;.
457            *
458            * @param companyId the company ID
459            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
460            * @return the last matching document library file version
461            * @throws NoSuchFileVersionException if a matching document library file version could not be found
462            */
463            public DLFileVersion findByCompanyId_Last(long companyId,
464                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
465                    throws NoSuchFileVersionException;
466    
467            /**
468            * Returns the last document library file version in the ordered set where companyId = &#63;.
469            *
470            * @param companyId the company ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
473            */
474            public DLFileVersion fetchByCompanyId_Last(long companyId,
475                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
476    
477            /**
478            * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = &#63;.
479            *
480            * @param fileVersionId the primary key of the current document library file version
481            * @param companyId the company ID
482            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
483            * @return the previous, current, and next document library file version
484            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
485            */
486            public DLFileVersion[] findByCompanyId_PrevAndNext(long fileVersionId,
487                    long companyId,
488                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
489                    throws NoSuchFileVersionException;
490    
491            /**
492            * Removes all the document library file versions where companyId = &#63; from the database.
493            *
494            * @param companyId the company ID
495            */
496            public void removeByCompanyId(long companyId);
497    
498            /**
499            * Returns the number of document library file versions where companyId = &#63;.
500            *
501            * @param companyId the company ID
502            * @return the number of matching document library file versions
503            */
504            public int countByCompanyId(long companyId);
505    
506            /**
507            * Returns all the document library file versions where fileEntryId = &#63;.
508            *
509            * @param fileEntryId the file entry ID
510            * @return the matching document library file versions
511            */
512            public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId);
513    
514            /**
515            * Returns a range of all the document library file versions where fileEntryId = &#63;.
516            *
517            * <p>
518            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
519            * </p>
520            *
521            * @param fileEntryId the file entry ID
522            * @param start the lower bound of the range of document library file versions
523            * @param end the upper bound of the range of document library file versions (not inclusive)
524            * @return the range of matching document library file versions
525            */
526            public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId,
527                    int start, int end);
528    
529            /**
530            * Returns an ordered range of all the document library file versions where fileEntryId = &#63;.
531            *
532            * <p>
533            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
534            * </p>
535            *
536            * @param fileEntryId the file entry ID
537            * @param start the lower bound of the range of document library file versions
538            * @param end the upper bound of the range of document library file versions (not inclusive)
539            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
540            * @return the ordered range of matching document library file versions
541            */
542            public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId,
543                    int start, int end,
544                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
545    
546            /**
547            * Returns an ordered range of all the document library file versions where fileEntryId = &#63;.
548            *
549            * <p>
550            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
551            * </p>
552            *
553            * @param fileEntryId the file entry ID
554            * @param start the lower bound of the range of document library file versions
555            * @param end the upper bound of the range of document library file versions (not inclusive)
556            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
557            * @param retrieveFromCache whether to retrieve from the finder cache
558            * @return the ordered range of matching document library file versions
559            */
560            public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId,
561                    int start, int end,
562                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
563                    boolean retrieveFromCache);
564    
565            /**
566            * Returns the first document library file version in the ordered set where fileEntryId = &#63;.
567            *
568            * @param fileEntryId the file entry ID
569            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
570            * @return the first matching document library file version
571            * @throws NoSuchFileVersionException if a matching document library file version could not be found
572            */
573            public DLFileVersion findByFileEntryId_First(long fileEntryId,
574                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
575                    throws NoSuchFileVersionException;
576    
577            /**
578            * Returns the first document library file version in the ordered set where fileEntryId = &#63;.
579            *
580            * @param fileEntryId the file entry ID
581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
582            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
583            */
584            public DLFileVersion fetchByFileEntryId_First(long fileEntryId,
585                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
586    
587            /**
588            * Returns the last document library file version in the ordered set where fileEntryId = &#63;.
589            *
590            * @param fileEntryId the file entry ID
591            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
592            * @return the last matching document library file version
593            * @throws NoSuchFileVersionException if a matching document library file version could not be found
594            */
595            public DLFileVersion findByFileEntryId_Last(long fileEntryId,
596                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
597                    throws NoSuchFileVersionException;
598    
599            /**
600            * Returns the last document library file version in the ordered set where fileEntryId = &#63;.
601            *
602            * @param fileEntryId the file entry ID
603            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
604            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
605            */
606            public DLFileVersion fetchByFileEntryId_Last(long fileEntryId,
607                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
608    
609            /**
610            * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = &#63;.
611            *
612            * @param fileVersionId the primary key of the current document library file version
613            * @param fileEntryId the file entry ID
614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
615            * @return the previous, current, and next document library file version
616            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
617            */
618            public DLFileVersion[] findByFileEntryId_PrevAndNext(long fileVersionId,
619                    long fileEntryId,
620                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
621                    throws NoSuchFileVersionException;
622    
623            /**
624            * Removes all the document library file versions where fileEntryId = &#63; from the database.
625            *
626            * @param fileEntryId the file entry ID
627            */
628            public void removeByFileEntryId(long fileEntryId);
629    
630            /**
631            * Returns the number of document library file versions where fileEntryId = &#63;.
632            *
633            * @param fileEntryId the file entry ID
634            * @return the number of matching document library file versions
635            */
636            public int countByFileEntryId(long fileEntryId);
637    
638            /**
639            * Returns all the document library file versions where mimeType = &#63;.
640            *
641            * @param mimeType the mime type
642            * @return the matching document library file versions
643            */
644            public java.util.List<DLFileVersion> findByMimeType(
645                    java.lang.String mimeType);
646    
647            /**
648            * Returns a range of all the document library file versions where mimeType = &#63;.
649            *
650            * <p>
651            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
652            * </p>
653            *
654            * @param mimeType the mime type
655            * @param start the lower bound of the range of document library file versions
656            * @param end the upper bound of the range of document library file versions (not inclusive)
657            * @return the range of matching document library file versions
658            */
659            public java.util.List<DLFileVersion> findByMimeType(
660                    java.lang.String mimeType, int start, int end);
661    
662            /**
663            * Returns an ordered range of all the document library file versions where mimeType = &#63;.
664            *
665            * <p>
666            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
667            * </p>
668            *
669            * @param mimeType the mime type
670            * @param start the lower bound of the range of document library file versions
671            * @param end the upper bound of the range of document library file versions (not inclusive)
672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
673            * @return the ordered range of matching document library file versions
674            */
675            public java.util.List<DLFileVersion> findByMimeType(
676                    java.lang.String mimeType, int start, int end,
677                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
678    
679            /**
680            * Returns an ordered range of all the document library file versions where mimeType = &#63;.
681            *
682            * <p>
683            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
684            * </p>
685            *
686            * @param mimeType the mime type
687            * @param start the lower bound of the range of document library file versions
688            * @param end the upper bound of the range of document library file versions (not inclusive)
689            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
690            * @param retrieveFromCache whether to retrieve from the finder cache
691            * @return the ordered range of matching document library file versions
692            */
693            public java.util.List<DLFileVersion> findByMimeType(
694                    java.lang.String mimeType, int start, int end,
695                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
696                    boolean retrieveFromCache);
697    
698            /**
699            * Returns the first document library file version in the ordered set where mimeType = &#63;.
700            *
701            * @param mimeType the mime type
702            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
703            * @return the first matching document library file version
704            * @throws NoSuchFileVersionException if a matching document library file version could not be found
705            */
706            public DLFileVersion findByMimeType_First(java.lang.String mimeType,
707                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
708                    throws NoSuchFileVersionException;
709    
710            /**
711            * Returns the first document library file version in the ordered set where mimeType = &#63;.
712            *
713            * @param mimeType the mime type
714            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
715            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
716            */
717            public DLFileVersion fetchByMimeType_First(java.lang.String mimeType,
718                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
719    
720            /**
721            * Returns the last document library file version in the ordered set where mimeType = &#63;.
722            *
723            * @param mimeType the mime type
724            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
725            * @return the last matching document library file version
726            * @throws NoSuchFileVersionException if a matching document library file version could not be found
727            */
728            public DLFileVersion findByMimeType_Last(java.lang.String mimeType,
729                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
730                    throws NoSuchFileVersionException;
731    
732            /**
733            * Returns the last document library file version in the ordered set where mimeType = &#63;.
734            *
735            * @param mimeType the mime type
736            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
737            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
738            */
739            public DLFileVersion fetchByMimeType_Last(java.lang.String mimeType,
740                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
741    
742            /**
743            * Returns the document library file versions before and after the current document library file version in the ordered set where mimeType = &#63;.
744            *
745            * @param fileVersionId the primary key of the current document library file version
746            * @param mimeType the mime type
747            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
748            * @return the previous, current, and next document library file version
749            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
750            */
751            public DLFileVersion[] findByMimeType_PrevAndNext(long fileVersionId,
752                    java.lang.String mimeType,
753                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
754                    throws NoSuchFileVersionException;
755    
756            /**
757            * Removes all the document library file versions where mimeType = &#63; from the database.
758            *
759            * @param mimeType the mime type
760            */
761            public void removeByMimeType(java.lang.String mimeType);
762    
763            /**
764            * Returns the number of document library file versions where mimeType = &#63;.
765            *
766            * @param mimeType the mime type
767            * @return the number of matching document library file versions
768            */
769            public int countByMimeType(java.lang.String mimeType);
770    
771            /**
772            * Returns all the document library file versions where companyId = &#63; and status &ne; &#63;.
773            *
774            * @param companyId the company ID
775            * @param status the status
776            * @return the matching document library file versions
777            */
778            public java.util.List<DLFileVersion> findByC_NotS(long companyId, int status);
779    
780            /**
781            * Returns a range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
782            *
783            * <p>
784            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
785            * </p>
786            *
787            * @param companyId the company ID
788            * @param status the status
789            * @param start the lower bound of the range of document library file versions
790            * @param end the upper bound of the range of document library file versions (not inclusive)
791            * @return the range of matching document library file versions
792            */
793            public java.util.List<DLFileVersion> findByC_NotS(long companyId,
794                    int status, int start, int end);
795    
796            /**
797            * Returns an ordered range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
798            *
799            * <p>
800            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
801            * </p>
802            *
803            * @param companyId the company ID
804            * @param status the status
805            * @param start the lower bound of the range of document library file versions
806            * @param end the upper bound of the range of document library file versions (not inclusive)
807            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
808            * @return the ordered range of matching document library file versions
809            */
810            public java.util.List<DLFileVersion> findByC_NotS(long companyId,
811                    int status, int start, int end,
812                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
813    
814            /**
815            * Returns an ordered range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
816            *
817            * <p>
818            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
819            * </p>
820            *
821            * @param companyId the company ID
822            * @param status the status
823            * @param start the lower bound of the range of document library file versions
824            * @param end the upper bound of the range of document library file versions (not inclusive)
825            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
826            * @param retrieveFromCache whether to retrieve from the finder cache
827            * @return the ordered range of matching document library file versions
828            */
829            public java.util.List<DLFileVersion> findByC_NotS(long companyId,
830                    int status, int start, int end,
831                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
832                    boolean retrieveFromCache);
833    
834            /**
835            * Returns the first document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
836            *
837            * @param companyId the company ID
838            * @param status the status
839            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
840            * @return the first matching document library file version
841            * @throws NoSuchFileVersionException if a matching document library file version could not be found
842            */
843            public DLFileVersion findByC_NotS_First(long companyId, int status,
844                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
845                    throws NoSuchFileVersionException;
846    
847            /**
848            * Returns the first document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
849            *
850            * @param companyId the company ID
851            * @param status the status
852            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
853            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
854            */
855            public DLFileVersion fetchByC_NotS_First(long companyId, int status,
856                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
857    
858            /**
859            * Returns the last document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
860            *
861            * @param companyId the company ID
862            * @param status the status
863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
864            * @return the last matching document library file version
865            * @throws NoSuchFileVersionException if a matching document library file version could not be found
866            */
867            public DLFileVersion findByC_NotS_Last(long companyId, int status,
868                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
869                    throws NoSuchFileVersionException;
870    
871            /**
872            * Returns the last document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
873            *
874            * @param companyId the company ID
875            * @param status the status
876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
877            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
878            */
879            public DLFileVersion fetchByC_NotS_Last(long companyId, int status,
880                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
881    
882            /**
883            * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
884            *
885            * @param fileVersionId the primary key of the current document library file version
886            * @param companyId the company ID
887            * @param status the status
888            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
889            * @return the previous, current, and next document library file version
890            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
891            */
892            public DLFileVersion[] findByC_NotS_PrevAndNext(long fileVersionId,
893                    long companyId, int status,
894                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
895                    throws NoSuchFileVersionException;
896    
897            /**
898            * Removes all the document library file versions where companyId = &#63; and status &ne; &#63; from the database.
899            *
900            * @param companyId the company ID
901            * @param status the status
902            */
903            public void removeByC_NotS(long companyId, int status);
904    
905            /**
906            * Returns the number of document library file versions where companyId = &#63; and status &ne; &#63;.
907            *
908            * @param companyId the company ID
909            * @param status the status
910            * @return the number of matching document library file versions
911            */
912            public int countByC_NotS(long companyId, int status);
913    
914            /**
915            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or throws a {@link NoSuchFileVersionException} if it could not be found.
916            *
917            * @param fileEntryId the file entry ID
918            * @param version the version
919            * @return the matching document library file version
920            * @throws NoSuchFileVersionException if a matching document library file version could not be found
921            */
922            public DLFileVersion findByF_V(long fileEntryId, java.lang.String version)
923                    throws NoSuchFileVersionException;
924    
925            /**
926            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
927            *
928            * @param fileEntryId the file entry ID
929            * @param version the version
930            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
931            */
932            public DLFileVersion fetchByF_V(long fileEntryId, java.lang.String version);
933    
934            /**
935            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
936            *
937            * @param fileEntryId the file entry ID
938            * @param version the version
939            * @param retrieveFromCache whether to retrieve from the finder cache
940            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
941            */
942            public DLFileVersion fetchByF_V(long fileEntryId, java.lang.String version,
943                    boolean retrieveFromCache);
944    
945            /**
946            * Removes the document library file version where fileEntryId = &#63; and version = &#63; from the database.
947            *
948            * @param fileEntryId the file entry ID
949            * @param version the version
950            * @return the document library file version that was removed
951            */
952            public DLFileVersion removeByF_V(long fileEntryId, java.lang.String version)
953                    throws NoSuchFileVersionException;
954    
955            /**
956            * Returns the number of document library file versions where fileEntryId = &#63; and version = &#63;.
957            *
958            * @param fileEntryId the file entry ID
959            * @param version the version
960            * @return the number of matching document library file versions
961            */
962            public int countByF_V(long fileEntryId, java.lang.String version);
963    
964            /**
965            * Returns all the document library file versions where fileEntryId = &#63; and status = &#63;.
966            *
967            * @param fileEntryId the file entry ID
968            * @param status the status
969            * @return the matching document library file versions
970            */
971            public java.util.List<DLFileVersion> findByF_S(long fileEntryId, int status);
972    
973            /**
974            * Returns a range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
975            *
976            * <p>
977            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
978            * </p>
979            *
980            * @param fileEntryId the file entry ID
981            * @param status the status
982            * @param start the lower bound of the range of document library file versions
983            * @param end the upper bound of the range of document library file versions (not inclusive)
984            * @return the range of matching document library file versions
985            */
986            public java.util.List<DLFileVersion> findByF_S(long fileEntryId,
987                    int status, int start, int end);
988    
989            /**
990            * Returns an ordered range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
991            *
992            * <p>
993            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
994            * </p>
995            *
996            * @param fileEntryId the file entry ID
997            * @param status the status
998            * @param start the lower bound of the range of document library file versions
999            * @param end the upper bound of the range of document library file versions (not inclusive)
1000            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1001            * @return the ordered range of matching document library file versions
1002            */
1003            public java.util.List<DLFileVersion> findByF_S(long fileEntryId,
1004                    int status, int start, int end,
1005                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1006    
1007            /**
1008            * Returns an ordered range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
1009            *
1010            * <p>
1011            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1012            * </p>
1013            *
1014            * @param fileEntryId the file entry ID
1015            * @param status the status
1016            * @param start the lower bound of the range of document library file versions
1017            * @param end the upper bound of the range of document library file versions (not inclusive)
1018            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1019            * @param retrieveFromCache whether to retrieve from the finder cache
1020            * @return the ordered range of matching document library file versions
1021            */
1022            public java.util.List<DLFileVersion> findByF_S(long fileEntryId,
1023                    int status, int start, int end,
1024                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
1025                    boolean retrieveFromCache);
1026    
1027            /**
1028            * Returns the first document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1029            *
1030            * @param fileEntryId the file entry ID
1031            * @param status the status
1032            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1033            * @return the first matching document library file version
1034            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1035            */
1036            public DLFileVersion findByF_S_First(long fileEntryId, int status,
1037                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1038                    throws NoSuchFileVersionException;
1039    
1040            /**
1041            * Returns the first document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1042            *
1043            * @param fileEntryId the file entry ID
1044            * @param status the status
1045            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1046            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1047            */
1048            public DLFileVersion fetchByF_S_First(long fileEntryId, int status,
1049                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1050    
1051            /**
1052            * Returns the last document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1053            *
1054            * @param fileEntryId the file entry ID
1055            * @param status the status
1056            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1057            * @return the last matching document library file version
1058            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1059            */
1060            public DLFileVersion findByF_S_Last(long fileEntryId, int status,
1061                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1062                    throws NoSuchFileVersionException;
1063    
1064            /**
1065            * Returns the last document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1066            *
1067            * @param fileEntryId the file entry ID
1068            * @param status the status
1069            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1070            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1071            */
1072            public DLFileVersion fetchByF_S_Last(long fileEntryId, int status,
1073                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1074    
1075            /**
1076            * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1077            *
1078            * @param fileVersionId the primary key of the current document library file version
1079            * @param fileEntryId the file entry ID
1080            * @param status the status
1081            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1082            * @return the previous, current, and next document library file version
1083            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1084            */
1085            public DLFileVersion[] findByF_S_PrevAndNext(long fileVersionId,
1086                    long fileEntryId, int status,
1087                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1088                    throws NoSuchFileVersionException;
1089    
1090            /**
1091            * Removes all the document library file versions where fileEntryId = &#63; and status = &#63; from the database.
1092            *
1093            * @param fileEntryId the file entry ID
1094            * @param status the status
1095            */
1096            public void removeByF_S(long fileEntryId, int status);
1097    
1098            /**
1099            * Returns the number of document library file versions where fileEntryId = &#63; and status = &#63;.
1100            *
1101            * @param fileEntryId the file entry ID
1102            * @param status the status
1103            * @return the number of matching document library file versions
1104            */
1105            public int countByF_S(long fileEntryId, int status);
1106    
1107            /**
1108            * Returns all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1109            *
1110            * @param groupId the group ID
1111            * @param folderId the folder ID
1112            * @param status the status
1113            * @return the matching document library file versions
1114            */
1115            public java.util.List<DLFileVersion> findByG_F_S(long groupId,
1116                    long folderId, int status);
1117    
1118            /**
1119            * Returns a range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1120            *
1121            * <p>
1122            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1123            * </p>
1124            *
1125            * @param groupId the group ID
1126            * @param folderId the folder ID
1127            * @param status the status
1128            * @param start the lower bound of the range of document library file versions
1129            * @param end the upper bound of the range of document library file versions (not inclusive)
1130            * @return the range of matching document library file versions
1131            */
1132            public java.util.List<DLFileVersion> findByG_F_S(long groupId,
1133                    long folderId, int status, int start, int end);
1134    
1135            /**
1136            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1137            *
1138            * <p>
1139            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1140            * </p>
1141            *
1142            * @param groupId the group ID
1143            * @param folderId the folder ID
1144            * @param status the status
1145            * @param start the lower bound of the range of document library file versions
1146            * @param end the upper bound of the range of document library file versions (not inclusive)
1147            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1148            * @return the ordered range of matching document library file versions
1149            */
1150            public java.util.List<DLFileVersion> findByG_F_S(long groupId,
1151                    long folderId, int status, int start, int end,
1152                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1153    
1154            /**
1155            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1156            *
1157            * <p>
1158            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1159            * </p>
1160            *
1161            * @param groupId the group ID
1162            * @param folderId the folder ID
1163            * @param status the status
1164            * @param start the lower bound of the range of document library file versions
1165            * @param end the upper bound of the range of document library file versions (not inclusive)
1166            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1167            * @param retrieveFromCache whether to retrieve from the finder cache
1168            * @return the ordered range of matching document library file versions
1169            */
1170            public java.util.List<DLFileVersion> findByG_F_S(long groupId,
1171                    long folderId, int status, int start, int end,
1172                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
1173                    boolean retrieveFromCache);
1174    
1175            /**
1176            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1177            *
1178            * @param groupId the group ID
1179            * @param folderId the folder ID
1180            * @param status the status
1181            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1182            * @return the first matching document library file version
1183            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1184            */
1185            public DLFileVersion findByG_F_S_First(long groupId, long folderId,
1186                    int status,
1187                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1188                    throws NoSuchFileVersionException;
1189    
1190            /**
1191            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1192            *
1193            * @param groupId the group ID
1194            * @param folderId the folder ID
1195            * @param status the status
1196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1197            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1198            */
1199            public DLFileVersion fetchByG_F_S_First(long groupId, long folderId,
1200                    int status,
1201                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1202    
1203            /**
1204            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1205            *
1206            * @param groupId the group ID
1207            * @param folderId the folder ID
1208            * @param status the status
1209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1210            * @return the last matching document library file version
1211            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1212            */
1213            public DLFileVersion findByG_F_S_Last(long groupId, long folderId,
1214                    int status,
1215                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1216                    throws NoSuchFileVersionException;
1217    
1218            /**
1219            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1220            *
1221            * @param groupId the group ID
1222            * @param folderId the folder ID
1223            * @param status the status
1224            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1225            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1226            */
1227            public DLFileVersion fetchByG_F_S_Last(long groupId, long folderId,
1228                    int status,
1229                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1230    
1231            /**
1232            * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1233            *
1234            * @param fileVersionId the primary key of the current document library file version
1235            * @param groupId the group ID
1236            * @param folderId the folder ID
1237            * @param status the status
1238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1239            * @return the previous, current, and next document library file version
1240            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1241            */
1242            public DLFileVersion[] findByG_F_S_PrevAndNext(long fileVersionId,
1243                    long groupId, long folderId, int status,
1244                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1245                    throws NoSuchFileVersionException;
1246    
1247            /**
1248            * Removes all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
1249            *
1250            * @param groupId the group ID
1251            * @param folderId the folder ID
1252            * @param status the status
1253            */
1254            public void removeByG_F_S(long groupId, long folderId, int status);
1255    
1256            /**
1257            * Returns the number of document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1258            *
1259            * @param groupId the group ID
1260            * @param folderId the folder ID
1261            * @param status the status
1262            * @return the number of matching document library file versions
1263            */
1264            public int countByG_F_S(long groupId, long folderId, int status);
1265    
1266            /**
1267            * Returns all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1268            *
1269            * @param groupId the group ID
1270            * @param folderId the folder ID
1271            * @param title the title
1272            * @param version the version
1273            * @return the matching document library file versions
1274            */
1275            public java.util.List<DLFileVersion> findByG_F_T_V(long groupId,
1276                    long folderId, java.lang.String title, java.lang.String version);
1277    
1278            /**
1279            * Returns a range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1280            *
1281            * <p>
1282            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1283            * </p>
1284            *
1285            * @param groupId the group ID
1286            * @param folderId the folder ID
1287            * @param title the title
1288            * @param version the version
1289            * @param start the lower bound of the range of document library file versions
1290            * @param end the upper bound of the range of document library file versions (not inclusive)
1291            * @return the range of matching document library file versions
1292            */
1293            public java.util.List<DLFileVersion> findByG_F_T_V(long groupId,
1294                    long folderId, java.lang.String title, java.lang.String version,
1295                    int start, int end);
1296    
1297            /**
1298            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1299            *
1300            * <p>
1301            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1302            * </p>
1303            *
1304            * @param groupId the group ID
1305            * @param folderId the folder ID
1306            * @param title the title
1307            * @param version the version
1308            * @param start the lower bound of the range of document library file versions
1309            * @param end the upper bound of the range of document library file versions (not inclusive)
1310            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1311            * @return the ordered range of matching document library file versions
1312            */
1313            public java.util.List<DLFileVersion> findByG_F_T_V(long groupId,
1314                    long folderId, java.lang.String title, java.lang.String version,
1315                    int start, int end,
1316                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1317    
1318            /**
1319            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1320            *
1321            * <p>
1322            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1323            * </p>
1324            *
1325            * @param groupId the group ID
1326            * @param folderId the folder ID
1327            * @param title the title
1328            * @param version the version
1329            * @param start the lower bound of the range of document library file versions
1330            * @param end the upper bound of the range of document library file versions (not inclusive)
1331            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1332            * @param retrieveFromCache whether to retrieve from the finder cache
1333            * @return the ordered range of matching document library file versions
1334            */
1335            public java.util.List<DLFileVersion> findByG_F_T_V(long groupId,
1336                    long folderId, java.lang.String title, java.lang.String version,
1337                    int start, int end,
1338                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
1339                    boolean retrieveFromCache);
1340    
1341            /**
1342            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1343            *
1344            * @param groupId the group ID
1345            * @param folderId the folder ID
1346            * @param title the title
1347            * @param version the version
1348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1349            * @return the first matching document library file version
1350            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1351            */
1352            public DLFileVersion findByG_F_T_V_First(long groupId, long folderId,
1353                    java.lang.String title, java.lang.String version,
1354                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1355                    throws NoSuchFileVersionException;
1356    
1357            /**
1358            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1359            *
1360            * @param groupId the group ID
1361            * @param folderId the folder ID
1362            * @param title the title
1363            * @param version the version
1364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1365            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1366            */
1367            public DLFileVersion fetchByG_F_T_V_First(long groupId, long folderId,
1368                    java.lang.String title, java.lang.String version,
1369                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1370    
1371            /**
1372            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1373            *
1374            * @param groupId the group ID
1375            * @param folderId the folder ID
1376            * @param title the title
1377            * @param version the version
1378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1379            * @return the last matching document library file version
1380            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1381            */
1382            public DLFileVersion findByG_F_T_V_Last(long groupId, long folderId,
1383                    java.lang.String title, java.lang.String version,
1384                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1385                    throws NoSuchFileVersionException;
1386    
1387            /**
1388            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1389            *
1390            * @param groupId the group ID
1391            * @param folderId the folder ID
1392            * @param title the title
1393            * @param version the version
1394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1395            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1396            */
1397            public DLFileVersion fetchByG_F_T_V_Last(long groupId, long folderId,
1398                    java.lang.String title, java.lang.String version,
1399                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1400    
1401            /**
1402            * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1403            *
1404            * @param fileVersionId the primary key of the current document library file version
1405            * @param groupId the group ID
1406            * @param folderId the folder ID
1407            * @param title the title
1408            * @param version the version
1409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1410            * @return the previous, current, and next document library file version
1411            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1412            */
1413            public DLFileVersion[] findByG_F_T_V_PrevAndNext(long fileVersionId,
1414                    long groupId, long folderId, java.lang.String title,
1415                    java.lang.String version,
1416                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator)
1417                    throws NoSuchFileVersionException;
1418    
1419            /**
1420            * Removes all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63; from the database.
1421            *
1422            * @param groupId the group ID
1423            * @param folderId the folder ID
1424            * @param title the title
1425            * @param version the version
1426            */
1427            public void removeByG_F_T_V(long groupId, long folderId,
1428                    java.lang.String title, java.lang.String version);
1429    
1430            /**
1431            * Returns the number of document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1432            *
1433            * @param groupId the group ID
1434            * @param folderId the folder ID
1435            * @param title the title
1436            * @param version the version
1437            * @return the number of matching document library file versions
1438            */
1439            public int countByG_F_T_V(long groupId, long folderId,
1440                    java.lang.String title, java.lang.String version);
1441    
1442            /**
1443            * Caches the document library file version in the entity cache if it is enabled.
1444            *
1445            * @param dlFileVersion the document library file version
1446            */
1447            public void cacheResult(DLFileVersion dlFileVersion);
1448    
1449            /**
1450            * Caches the document library file versions in the entity cache if it is enabled.
1451            *
1452            * @param dlFileVersions the document library file versions
1453            */
1454            public void cacheResult(java.util.List<DLFileVersion> dlFileVersions);
1455    
1456            /**
1457            * Creates a new document library file version with the primary key. Does not add the document library file version to the database.
1458            *
1459            * @param fileVersionId the primary key for the new document library file version
1460            * @return the new document library file version
1461            */
1462            public DLFileVersion create(long fileVersionId);
1463    
1464            /**
1465            * Removes the document library file version with the primary key from the database. Also notifies the appropriate model listeners.
1466            *
1467            * @param fileVersionId the primary key of the document library file version
1468            * @return the document library file version that was removed
1469            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1470            */
1471            public DLFileVersion remove(long fileVersionId)
1472                    throws NoSuchFileVersionException;
1473    
1474            public DLFileVersion updateImpl(DLFileVersion dlFileVersion);
1475    
1476            /**
1477            * Returns the document library file version with the primary key or throws a {@link NoSuchFileVersionException} if it could not be found.
1478            *
1479            * @param fileVersionId the primary key of the document library file version
1480            * @return the document library file version
1481            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1482            */
1483            public DLFileVersion findByPrimaryKey(long fileVersionId)
1484                    throws NoSuchFileVersionException;
1485    
1486            /**
1487            * Returns the document library file version with the primary key or returns <code>null</code> if it could not be found.
1488            *
1489            * @param fileVersionId the primary key of the document library file version
1490            * @return the document library file version, or <code>null</code> if a document library file version with the primary key could not be found
1491            */
1492            public DLFileVersion fetchByPrimaryKey(long fileVersionId);
1493    
1494            @Override
1495            public java.util.Map<java.io.Serializable, DLFileVersion> fetchByPrimaryKeys(
1496                    java.util.Set<java.io.Serializable> primaryKeys);
1497    
1498            /**
1499            * Returns all the document library file versions.
1500            *
1501            * @return the document library file versions
1502            */
1503            public java.util.List<DLFileVersion> findAll();
1504    
1505            /**
1506            * Returns a range of all the document library file versions.
1507            *
1508            * <p>
1509            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1510            * </p>
1511            *
1512            * @param start the lower bound of the range of document library file versions
1513            * @param end the upper bound of the range of document library file versions (not inclusive)
1514            * @return the range of document library file versions
1515            */
1516            public java.util.List<DLFileVersion> findAll(int start, int end);
1517    
1518            /**
1519            * Returns an ordered range of all the document library file versions.
1520            *
1521            * <p>
1522            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1523            * </p>
1524            *
1525            * @param start the lower bound of the range of document library file versions
1526            * @param end the upper bound of the range of document library file versions (not inclusive)
1527            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1528            * @return the ordered range of document library file versions
1529            */
1530            public java.util.List<DLFileVersion> findAll(int start, int end,
1531                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator);
1532    
1533            /**
1534            * Returns an ordered range of all the document library file versions.
1535            *
1536            * <p>
1537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1538            * </p>
1539            *
1540            * @param start the lower bound of the range of document library file versions
1541            * @param end the upper bound of the range of document library file versions (not inclusive)
1542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1543            * @param retrieveFromCache whether to retrieve from the finder cache
1544            * @return the ordered range of document library file versions
1545            */
1546            public java.util.List<DLFileVersion> findAll(int start, int end,
1547                    com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator,
1548                    boolean retrieveFromCache);
1549    
1550            /**
1551            * Removes all the document library file versions from the database.
1552            */
1553            public void removeAll();
1554    
1555            /**
1556            * Returns the number of document library file versions.
1557            *
1558            * @return the number of document library file versions
1559            */
1560            public int countAll();
1561    
1562            @Override
1563            public java.util.Set<java.lang.String> getBadColumnNames();
1564    }