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