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.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.documentlibrary.model.DLFileEntryType;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the document library file entry type service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryTypePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see DLFileEntryTypePersistence
038     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryTypePersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DLFileEntryTypeUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(DLFileEntryType dlFileEntryType) {
060                    getPersistence().clearCache(dlFileEntryType);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<DLFileEntryType> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<DLFileEntryType> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<DLFileEntryType> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DLFileEntryType> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static DLFileEntryType update(DLFileEntryType dlFileEntryType) {
101                    return getPersistence().update(dlFileEntryType);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DLFileEntryType update(DLFileEntryType dlFileEntryType,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(dlFileEntryType, serviceContext);
110            }
111    
112            /**
113            * Returns all the document library file entry types where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching document library file entry types
117            */
118            public static List<DLFileEntryType> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the document library file entry types where uuid = &#63;.
124            *
125            * <p>
126            * 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 DLFileEntryTypeModelImpl}. 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of document library file entry types
131            * @param end the upper bound of the range of document library file entry types (not inclusive)
132            * @return the range of matching document library file entry types
133            */
134            public static List<DLFileEntryType> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the document library file entry types where uuid = &#63;.
141            *
142            * <p>
143            * 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 DLFileEntryTypeModelImpl}. 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of document library file entry types
148            * @param end the upper bound of the range of document library file entry types (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching document library file entry types
151            */
152            public static List<DLFileEntryType> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the document library file entry types where uuid = &#63;.
159            *
160            * <p>
161            * 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 DLFileEntryTypeModelImpl}. 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.
162            * </p>
163            *
164            * @param uuid the uuid
165            * @param start the lower bound of the range of document library file entry types
166            * @param end the upper bound of the range of document library file entry types (not inclusive)
167            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
168            * @param retrieveFromCache whether to retrieve from the finder cache
169            * @return the ordered range of matching document library file entry types
170            */
171            public static List<DLFileEntryType> findByUuid(java.lang.String uuid,
172                    int start, int end,
173                    OrderByComparator<DLFileEntryType> orderByComparator,
174                    boolean retrieveFromCache) {
175                    return getPersistence()
176                                       .findByUuid(uuid, start, end, orderByComparator,
177                            retrieveFromCache);
178            }
179    
180            /**
181            * Returns the first document library file entry type in the ordered set where uuid = &#63;.
182            *
183            * @param uuid the uuid
184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
185            * @return the first matching document library file entry type
186            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
187            */
188            public static DLFileEntryType findByUuid_First(java.lang.String uuid,
189                    OrderByComparator<DLFileEntryType> orderByComparator)
190                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
191                    return getPersistence().findByUuid_First(uuid, orderByComparator);
192            }
193    
194            /**
195            * Returns the first document library file entry type in the ordered set where uuid = &#63;.
196            *
197            * @param uuid the uuid
198            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
199            * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
200            */
201            public static DLFileEntryType fetchByUuid_First(java.lang.String uuid,
202                    OrderByComparator<DLFileEntryType> orderByComparator) {
203                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
204            }
205    
206            /**
207            * Returns the last document library file entry type in the ordered set where uuid = &#63;.
208            *
209            * @param uuid the uuid
210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
211            * @return the last matching document library file entry type
212            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
213            */
214            public static DLFileEntryType findByUuid_Last(java.lang.String uuid,
215                    OrderByComparator<DLFileEntryType> orderByComparator)
216                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
217                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
218            }
219    
220            /**
221            * Returns the last document library file entry type in the ordered set where uuid = &#63;.
222            *
223            * @param uuid the uuid
224            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
225            * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
226            */
227            public static DLFileEntryType fetchByUuid_Last(java.lang.String uuid,
228                    OrderByComparator<DLFileEntryType> orderByComparator) {
229                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
230            }
231    
232            /**
233            * Returns the document library file entry types before and after the current document library file entry type in the ordered set where uuid = &#63;.
234            *
235            * @param fileEntryTypeId the primary key of the current document library file entry type
236            * @param uuid the uuid
237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
238            * @return the previous, current, and next document library file entry type
239            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
240            */
241            public static DLFileEntryType[] findByUuid_PrevAndNext(
242                    long fileEntryTypeId, java.lang.String uuid,
243                    OrderByComparator<DLFileEntryType> orderByComparator)
244                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(fileEntryTypeId, uuid,
247                            orderByComparator);
248            }
249    
250            /**
251            * Removes all the document library file entry types where uuid = &#63; from the database.
252            *
253            * @param uuid the uuid
254            */
255            public static void removeByUuid(java.lang.String uuid) {
256                    getPersistence().removeByUuid(uuid);
257            }
258    
259            /**
260            * Returns the number of document library file entry types where uuid = &#63;.
261            *
262            * @param uuid the uuid
263            * @return the number of matching document library file entry types
264            */
265            public static int countByUuid(java.lang.String uuid) {
266                    return getPersistence().countByUuid(uuid);
267            }
268    
269            /**
270            * Returns the document library file entry type where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFileEntryTypeException} if it could not be found.
271            *
272            * @param uuid the uuid
273            * @param groupId the group ID
274            * @return the matching document library file entry type
275            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
276            */
277            public static DLFileEntryType findByUUID_G(java.lang.String uuid,
278                    long groupId)
279                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
280                    return getPersistence().findByUUID_G(uuid, groupId);
281            }
282    
283            /**
284            * Returns the document library file entry type where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
285            *
286            * @param uuid the uuid
287            * @param groupId the group ID
288            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
289            */
290            public static DLFileEntryType fetchByUUID_G(java.lang.String uuid,
291                    long groupId) {
292                    return getPersistence().fetchByUUID_G(uuid, groupId);
293            }
294    
295            /**
296            * Returns the document library file entry type where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
297            *
298            * @param uuid the uuid
299            * @param groupId the group ID
300            * @param retrieveFromCache whether to retrieve from the finder cache
301            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
302            */
303            public static DLFileEntryType fetchByUUID_G(java.lang.String uuid,
304                    long groupId, boolean retrieveFromCache) {
305                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
306            }
307    
308            /**
309            * Removes the document library file entry type where uuid = &#63; and groupId = &#63; from the database.
310            *
311            * @param uuid the uuid
312            * @param groupId the group ID
313            * @return the document library file entry type that was removed
314            */
315            public static DLFileEntryType removeByUUID_G(java.lang.String uuid,
316                    long groupId)
317                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
318                    return getPersistence().removeByUUID_G(uuid, groupId);
319            }
320    
321            /**
322            * Returns the number of document library file entry types where uuid = &#63; and groupId = &#63;.
323            *
324            * @param uuid the uuid
325            * @param groupId the group ID
326            * @return the number of matching document library file entry types
327            */
328            public static int countByUUID_G(java.lang.String uuid, long groupId) {
329                    return getPersistence().countByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns all the document library file entry types where uuid = &#63; and companyId = &#63;.
334            *
335            * @param uuid the uuid
336            * @param companyId the company ID
337            * @return the matching document library file entry types
338            */
339            public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid,
340                    long companyId) {
341                    return getPersistence().findByUuid_C(uuid, companyId);
342            }
343    
344            /**
345            * Returns a range of all the document library file entry types where uuid = &#63; and companyId = &#63;.
346            *
347            * <p>
348            * 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 DLFileEntryTypeModelImpl}. 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.
349            * </p>
350            *
351            * @param uuid the uuid
352            * @param companyId the company ID
353            * @param start the lower bound of the range of document library file entry types
354            * @param end the upper bound of the range of document library file entry types (not inclusive)
355            * @return the range of matching document library file entry types
356            */
357            public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid,
358                    long companyId, int start, int end) {
359                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
360            }
361    
362            /**
363            * Returns an ordered range of all the document library file entry types where uuid = &#63; and companyId = &#63;.
364            *
365            * <p>
366            * 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 DLFileEntryTypeModelImpl}. 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.
367            * </p>
368            *
369            * @param uuid the uuid
370            * @param companyId the company ID
371            * @param start the lower bound of the range of document library file entry types
372            * @param end the upper bound of the range of document library file entry types (not inclusive)
373            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
374            * @return the ordered range of matching document library file entry types
375            */
376            public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid,
377                    long companyId, int start, int end,
378                    OrderByComparator<DLFileEntryType> orderByComparator) {
379                    return getPersistence()
380                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
381            }
382    
383            /**
384            * Returns an ordered range of all the document library file entry types where uuid = &#63; and companyId = &#63;.
385            *
386            * <p>
387            * 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 DLFileEntryTypeModelImpl}. 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.
388            * </p>
389            *
390            * @param uuid the uuid
391            * @param companyId the company ID
392            * @param start the lower bound of the range of document library file entry types
393            * @param end the upper bound of the range of document library file entry types (not inclusive)
394            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
395            * @param retrieveFromCache whether to retrieve from the finder cache
396            * @return the ordered range of matching document library file entry types
397            */
398            public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid,
399                    long companyId, int start, int end,
400                    OrderByComparator<DLFileEntryType> orderByComparator,
401                    boolean retrieveFromCache) {
402                    return getPersistence()
403                                       .findByUuid_C(uuid, companyId, start, end,
404                            orderByComparator, retrieveFromCache);
405            }
406    
407            /**
408            * Returns the first document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
409            *
410            * @param uuid the uuid
411            * @param companyId the company ID
412            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
413            * @return the first matching document library file entry type
414            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
415            */
416            public static DLFileEntryType findByUuid_C_First(java.lang.String uuid,
417                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator)
418                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
419                    return getPersistence()
420                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
421            }
422    
423            /**
424            * Returns the first document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
425            *
426            * @param uuid the uuid
427            * @param companyId the company ID
428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
429            * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
430            */
431            public static DLFileEntryType fetchByUuid_C_First(java.lang.String uuid,
432                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator) {
433                    return getPersistence()
434                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
435            }
436    
437            /**
438            * Returns the last document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
439            *
440            * @param uuid the uuid
441            * @param companyId the company ID
442            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
443            * @return the last matching document library file entry type
444            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
445            */
446            public static DLFileEntryType findByUuid_C_Last(java.lang.String uuid,
447                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator)
448                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
449                    return getPersistence()
450                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
451            }
452    
453            /**
454            * Returns the last document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
455            *
456            * @param uuid the uuid
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 entry type, or <code>null</code> if a matching document library file entry type could not be found
460            */
461            public static DLFileEntryType fetchByUuid_C_Last(java.lang.String uuid,
462                    long companyId, OrderByComparator<DLFileEntryType> orderByComparator) {
463                    return getPersistence()
464                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
465            }
466    
467            /**
468            * Returns the document library file entry types before and after the current document library file entry type in the ordered set where uuid = &#63; and companyId = &#63;.
469            *
470            * @param fileEntryTypeId the primary key of the current document library file entry type
471            * @param uuid the uuid
472            * @param companyId the company ID
473            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
474            * @return the previous, current, and next document library file entry type
475            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
476            */
477            public static DLFileEntryType[] findByUuid_C_PrevAndNext(
478                    long fileEntryTypeId, java.lang.String uuid, long companyId,
479                    OrderByComparator<DLFileEntryType> orderByComparator)
480                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
481                    return getPersistence()
482                                       .findByUuid_C_PrevAndNext(fileEntryTypeId, uuid, companyId,
483                            orderByComparator);
484            }
485    
486            /**
487            * Removes all the document library file entry types where uuid = &#63; and companyId = &#63; from the database.
488            *
489            * @param uuid the uuid
490            * @param companyId the company ID
491            */
492            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
493                    getPersistence().removeByUuid_C(uuid, companyId);
494            }
495    
496            /**
497            * Returns the number of document library file entry types where uuid = &#63; and companyId = &#63;.
498            *
499            * @param uuid the uuid
500            * @param companyId the company ID
501            * @return the number of matching document library file entry types
502            */
503            public static int countByUuid_C(java.lang.String uuid, long companyId) {
504                    return getPersistence().countByUuid_C(uuid, companyId);
505            }
506    
507            /**
508            * Returns all the document library file entry types where groupId = &#63;.
509            *
510            * @param groupId the group ID
511            * @return the matching document library file entry types
512            */
513            public static List<DLFileEntryType> findByGroupId(long groupId) {
514                    return getPersistence().findByGroupId(groupId);
515            }
516    
517            /**
518            * Returns a range of all the document library file entry types where groupId = &#63;.
519            *
520            * <p>
521            * 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 DLFileEntryTypeModelImpl}. 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.
522            * </p>
523            *
524            * @param groupId the group ID
525            * @param start the lower bound of the range of document library file entry types
526            * @param end the upper bound of the range of document library file entry types (not inclusive)
527            * @return the range of matching document library file entry types
528            */
529            public static List<DLFileEntryType> findByGroupId(long groupId, int start,
530                    int end) {
531                    return getPersistence().findByGroupId(groupId, start, end);
532            }
533    
534            /**
535            * Returns an ordered range of all the document library file entry types where groupId = &#63;.
536            *
537            * <p>
538            * 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 DLFileEntryTypeModelImpl}. 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.
539            * </p>
540            *
541            * @param groupId the group ID
542            * @param start the lower bound of the range of document library file entry types
543            * @param end the upper bound of the range of document library file entry types (not inclusive)
544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
545            * @return the ordered range of matching document library file entry types
546            */
547            public static List<DLFileEntryType> findByGroupId(long groupId, int start,
548                    int end, OrderByComparator<DLFileEntryType> orderByComparator) {
549                    return getPersistence()
550                                       .findByGroupId(groupId, start, end, orderByComparator);
551            }
552    
553            /**
554            * Returns an ordered range of all the document library file entry types where groupId = &#63;.
555            *
556            * <p>
557            * 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 DLFileEntryTypeModelImpl}. 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.
558            * </p>
559            *
560            * @param groupId the group ID
561            * @param start the lower bound of the range of document library file entry types
562            * @param end the upper bound of the range of document library file entry types (not inclusive)
563            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
564            * @param retrieveFromCache whether to retrieve from the finder cache
565            * @return the ordered range of matching document library file entry types
566            */
567            public static List<DLFileEntryType> findByGroupId(long groupId, int start,
568                    int end, OrderByComparator<DLFileEntryType> orderByComparator,
569                    boolean retrieveFromCache) {
570                    return getPersistence()
571                                       .findByGroupId(groupId, start, end, orderByComparator,
572                            retrieveFromCache);
573            }
574    
575            /**
576            * Returns the first document library file entry type in the ordered set where groupId = &#63;.
577            *
578            * @param groupId the group ID
579            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
580            * @return the first matching document library file entry type
581            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
582            */
583            public static DLFileEntryType findByGroupId_First(long groupId,
584                    OrderByComparator<DLFileEntryType> orderByComparator)
585                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
586                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
587            }
588    
589            /**
590            * Returns the first document library file entry type in the ordered set where groupId = &#63;.
591            *
592            * @param groupId the group ID
593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
594            * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
595            */
596            public static DLFileEntryType fetchByGroupId_First(long groupId,
597                    OrderByComparator<DLFileEntryType> orderByComparator) {
598                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
599            }
600    
601            /**
602            * Returns the last document library file entry type in the ordered set where groupId = &#63;.
603            *
604            * @param groupId the group ID
605            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
606            * @return the last matching document library file entry type
607            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
608            */
609            public static DLFileEntryType findByGroupId_Last(long groupId,
610                    OrderByComparator<DLFileEntryType> orderByComparator)
611                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
612                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
613            }
614    
615            /**
616            * Returns the last document library file entry type in the ordered set where groupId = &#63;.
617            *
618            * @param groupId the group ID
619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
620            * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
621            */
622            public static DLFileEntryType fetchByGroupId_Last(long groupId,
623                    OrderByComparator<DLFileEntryType> orderByComparator) {
624                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
625            }
626    
627            /**
628            * Returns the document library file entry types before and after the current document library file entry type in the ordered set where groupId = &#63;.
629            *
630            * @param fileEntryTypeId the primary key of the current document library file entry type
631            * @param groupId the group ID
632            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
633            * @return the previous, current, and next document library file entry type
634            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
635            */
636            public static DLFileEntryType[] findByGroupId_PrevAndNext(
637                    long fileEntryTypeId, long groupId,
638                    OrderByComparator<DLFileEntryType> orderByComparator)
639                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
640                    return getPersistence()
641                                       .findByGroupId_PrevAndNext(fileEntryTypeId, groupId,
642                            orderByComparator);
643            }
644    
645            /**
646            * Returns all the document library file entry types that the user has permission to view where groupId = &#63;.
647            *
648            * @param groupId the group ID
649            * @return the matching document library file entry types that the user has permission to view
650            */
651            public static List<DLFileEntryType> filterFindByGroupId(long groupId) {
652                    return getPersistence().filterFindByGroupId(groupId);
653            }
654    
655            /**
656            * Returns a range of all the document library file entry types that the user has permission to view where groupId = &#63;.
657            *
658            * <p>
659            * 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 DLFileEntryTypeModelImpl}. 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.
660            * </p>
661            *
662            * @param groupId the group ID
663            * @param start the lower bound of the range of document library file entry types
664            * @param end the upper bound of the range of document library file entry types (not inclusive)
665            * @return the range of matching document library file entry types that the user has permission to view
666            */
667            public static List<DLFileEntryType> filterFindByGroupId(long groupId,
668                    int start, int end) {
669                    return getPersistence().filterFindByGroupId(groupId, start, end);
670            }
671    
672            /**
673            * Returns an ordered range of all the document library file entry types that the user has permissions to view where groupId = &#63;.
674            *
675            * <p>
676            * 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 DLFileEntryTypeModelImpl}. 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.
677            * </p>
678            *
679            * @param groupId the group ID
680            * @param start the lower bound of the range of document library file entry types
681            * @param end the upper bound of the range of document library file entry types (not inclusive)
682            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
683            * @return the ordered range of matching document library file entry types that the user has permission to view
684            */
685            public static List<DLFileEntryType> filterFindByGroupId(long groupId,
686                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
687                    return getPersistence()
688                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
689            }
690    
691            /**
692            * Returns the document library file entry types before and after the current document library file entry type in the ordered set of document library file entry types that the user has permission to view where groupId = &#63;.
693            *
694            * @param fileEntryTypeId the primary key of the current document library file entry type
695            * @param groupId the group ID
696            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
697            * @return the previous, current, and next document library file entry type
698            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
699            */
700            public static DLFileEntryType[] filterFindByGroupId_PrevAndNext(
701                    long fileEntryTypeId, long groupId,
702                    OrderByComparator<DLFileEntryType> orderByComparator)
703                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
704                    return getPersistence()
705                                       .filterFindByGroupId_PrevAndNext(fileEntryTypeId, groupId,
706                            orderByComparator);
707            }
708    
709            /**
710            * Returns all the document library file entry types that the user has permission to view where groupId = any &#63;.
711            *
712            * @param groupIds the group IDs
713            * @return the matching document library file entry types that the user has permission to view
714            */
715            public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds) {
716                    return getPersistence().filterFindByGroupId(groupIds);
717            }
718    
719            /**
720            * Returns a range of all the document library file entry types that the user has permission to view where groupId = any &#63;.
721            *
722            * <p>
723            * 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 DLFileEntryTypeModelImpl}. 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.
724            * </p>
725            *
726            * @param groupIds the group IDs
727            * @param start the lower bound of the range of document library file entry types
728            * @param end the upper bound of the range of document library file entry types (not inclusive)
729            * @return the range of matching document library file entry types that the user has permission to view
730            */
731            public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds,
732                    int start, int end) {
733                    return getPersistence().filterFindByGroupId(groupIds, start, end);
734            }
735    
736            /**
737            * Returns an ordered range of all the document library file entry types that the user has permission to view where groupId = any &#63;.
738            *
739            * <p>
740            * 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 DLFileEntryTypeModelImpl}. 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.
741            * </p>
742            *
743            * @param groupIds the group IDs
744            * @param start the lower bound of the range of document library file entry types
745            * @param end the upper bound of the range of document library file entry types (not inclusive)
746            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
747            * @return the ordered range of matching document library file entry types that the user has permission to view
748            */
749            public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds,
750                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
751                    return getPersistence()
752                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
753            }
754    
755            /**
756            * Returns all the document library file entry types where groupId = any &#63;.
757            *
758            * <p>
759            * 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 DLFileEntryTypeModelImpl}. 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.
760            * </p>
761            *
762            * @param groupIds the group IDs
763            * @return the matching document library file entry types
764            */
765            public static List<DLFileEntryType> findByGroupId(long[] groupIds) {
766                    return getPersistence().findByGroupId(groupIds);
767            }
768    
769            /**
770            * Returns a range of all the document library file entry types where groupId = any &#63;.
771            *
772            * <p>
773            * 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 DLFileEntryTypeModelImpl}. 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.
774            * </p>
775            *
776            * @param groupIds the group IDs
777            * @param start the lower bound of the range of document library file entry types
778            * @param end the upper bound of the range of document library file entry types (not inclusive)
779            * @return the range of matching document library file entry types
780            */
781            public static List<DLFileEntryType> findByGroupId(long[] groupIds,
782                    int start, int end) {
783                    return getPersistence().findByGroupId(groupIds, start, end);
784            }
785    
786            /**
787            * Returns an ordered range of all the document library file entry types where groupId = any &#63;.
788            *
789            * <p>
790            * 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 DLFileEntryTypeModelImpl}. 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.
791            * </p>
792            *
793            * @param groupIds the group IDs
794            * @param start the lower bound of the range of document library file entry types
795            * @param end the upper bound of the range of document library file entry types (not inclusive)
796            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
797            * @return the ordered range of matching document library file entry types
798            */
799            public static List<DLFileEntryType> findByGroupId(long[] groupIds,
800                    int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) {
801                    return getPersistence()
802                                       .findByGroupId(groupIds, start, end, orderByComparator);
803            }
804    
805            /**
806            * Returns an ordered range of all the document library file entry types where groupId = &#63;, optionally using the finder cache.
807            *
808            * <p>
809            * 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 DLFileEntryTypeModelImpl}. 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.
810            * </p>
811            *
812            * @param groupId the group ID
813            * @param start the lower bound of the range of document library file entry types
814            * @param end the upper bound of the range of document library file entry types (not inclusive)
815            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
816            * @param retrieveFromCache whether to retrieve from the finder cache
817            * @return the ordered range of matching document library file entry types
818            */
819            public static List<DLFileEntryType> findByGroupId(long[] groupIds,
820                    int start, int end,
821                    OrderByComparator<DLFileEntryType> orderByComparator,
822                    boolean retrieveFromCache) {
823                    return getPersistence()
824                                       .findByGroupId(groupIds, start, end, orderByComparator,
825                            retrieveFromCache);
826            }
827    
828            /**
829            * Removes all the document library file entry types where groupId = &#63; from the database.
830            *
831            * @param groupId the group ID
832            */
833            public static void removeByGroupId(long groupId) {
834                    getPersistence().removeByGroupId(groupId);
835            }
836    
837            /**
838            * Returns the number of document library file entry types where groupId = &#63;.
839            *
840            * @param groupId the group ID
841            * @return the number of matching document library file entry types
842            */
843            public static int countByGroupId(long groupId) {
844                    return getPersistence().countByGroupId(groupId);
845            }
846    
847            /**
848            * Returns the number of document library file entry types where groupId = any &#63;.
849            *
850            * @param groupIds the group IDs
851            * @return the number of matching document library file entry types
852            */
853            public static int countByGroupId(long[] groupIds) {
854                    return getPersistence().countByGroupId(groupIds);
855            }
856    
857            /**
858            * Returns the number of document library file entry types that the user has permission to view where groupId = &#63;.
859            *
860            * @param groupId the group ID
861            * @return the number of matching document library file entry types that the user has permission to view
862            */
863            public static int filterCountByGroupId(long groupId) {
864                    return getPersistence().filterCountByGroupId(groupId);
865            }
866    
867            /**
868            * Returns the number of document library file entry types that the user has permission to view where groupId = any &#63;.
869            *
870            * @param groupIds the group IDs
871            * @return the number of matching document library file entry types that the user has permission to view
872            */
873            public static int filterCountByGroupId(long[] groupIds) {
874                    return getPersistence().filterCountByGroupId(groupIds);
875            }
876    
877            /**
878            * Returns the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; or throws a {@link NoSuchFileEntryTypeException} if it could not be found.
879            *
880            * @param groupId the group ID
881            * @param fileEntryTypeKey the file entry type key
882            * @return the matching document library file entry type
883            * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found
884            */
885            public static DLFileEntryType findByG_F(long groupId,
886                    java.lang.String fileEntryTypeKey)
887                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
888                    return getPersistence().findByG_F(groupId, fileEntryTypeKey);
889            }
890    
891            /**
892            * Returns the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
893            *
894            * @param groupId the group ID
895            * @param fileEntryTypeKey the file entry type key
896            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
897            */
898            public static DLFileEntryType fetchByG_F(long groupId,
899                    java.lang.String fileEntryTypeKey) {
900                    return getPersistence().fetchByG_F(groupId, fileEntryTypeKey);
901            }
902    
903            /**
904            * Returns the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
905            *
906            * @param groupId the group ID
907            * @param fileEntryTypeKey the file entry type key
908            * @param retrieveFromCache whether to retrieve from the finder cache
909            * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found
910            */
911            public static DLFileEntryType fetchByG_F(long groupId,
912                    java.lang.String fileEntryTypeKey, boolean retrieveFromCache) {
913                    return getPersistence()
914                                       .fetchByG_F(groupId, fileEntryTypeKey, retrieveFromCache);
915            }
916    
917            /**
918            * Removes the document library file entry type where groupId = &#63; and fileEntryTypeKey = &#63; from the database.
919            *
920            * @param groupId the group ID
921            * @param fileEntryTypeKey the file entry type key
922            * @return the document library file entry type that was removed
923            */
924            public static DLFileEntryType removeByG_F(long groupId,
925                    java.lang.String fileEntryTypeKey)
926                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
927                    return getPersistence().removeByG_F(groupId, fileEntryTypeKey);
928            }
929    
930            /**
931            * Returns the number of document library file entry types where groupId = &#63; and fileEntryTypeKey = &#63;.
932            *
933            * @param groupId the group ID
934            * @param fileEntryTypeKey the file entry type key
935            * @return the number of matching document library file entry types
936            */
937            public static int countByG_F(long groupId, java.lang.String fileEntryTypeKey) {
938                    return getPersistence().countByG_F(groupId, fileEntryTypeKey);
939            }
940    
941            /**
942            * Caches the document library file entry type in the entity cache if it is enabled.
943            *
944            * @param dlFileEntryType the document library file entry type
945            */
946            public static void cacheResult(DLFileEntryType dlFileEntryType) {
947                    getPersistence().cacheResult(dlFileEntryType);
948            }
949    
950            /**
951            * Caches the document library file entry types in the entity cache if it is enabled.
952            *
953            * @param dlFileEntryTypes the document library file entry types
954            */
955            public static void cacheResult(List<DLFileEntryType> dlFileEntryTypes) {
956                    getPersistence().cacheResult(dlFileEntryTypes);
957            }
958    
959            /**
960            * Creates a new document library file entry type with the primary key. Does not add the document library file entry type to the database.
961            *
962            * @param fileEntryTypeId the primary key for the new document library file entry type
963            * @return the new document library file entry type
964            */
965            public static DLFileEntryType create(long fileEntryTypeId) {
966                    return getPersistence().create(fileEntryTypeId);
967            }
968    
969            /**
970            * Removes the document library file entry type with the primary key from the database. Also notifies the appropriate model listeners.
971            *
972            * @param fileEntryTypeId the primary key of the document library file entry type
973            * @return the document library file entry type that was removed
974            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
975            */
976            public static DLFileEntryType remove(long fileEntryTypeId)
977                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
978                    return getPersistence().remove(fileEntryTypeId);
979            }
980    
981            public static DLFileEntryType updateImpl(DLFileEntryType dlFileEntryType) {
982                    return getPersistence().updateImpl(dlFileEntryType);
983            }
984    
985            /**
986            * Returns the document library file entry type with the primary key or throws a {@link NoSuchFileEntryTypeException} if it could not be found.
987            *
988            * @param fileEntryTypeId the primary key of the document library file entry type
989            * @return the document library file entry type
990            * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found
991            */
992            public static DLFileEntryType findByPrimaryKey(long fileEntryTypeId)
993                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException {
994                    return getPersistence().findByPrimaryKey(fileEntryTypeId);
995            }
996    
997            /**
998            * Returns the document library file entry type with the primary key or returns <code>null</code> if it could not be found.
999            *
1000            * @param fileEntryTypeId the primary key of the document library file entry type
1001            * @return the document library file entry type, or <code>null</code> if a document library file entry type with the primary key could not be found
1002            */
1003            public static DLFileEntryType fetchByPrimaryKey(long fileEntryTypeId) {
1004                    return getPersistence().fetchByPrimaryKey(fileEntryTypeId);
1005            }
1006    
1007            public static java.util.Map<java.io.Serializable, DLFileEntryType> fetchByPrimaryKeys(
1008                    java.util.Set<java.io.Serializable> primaryKeys) {
1009                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1010            }
1011    
1012            /**
1013            * Returns all the document library file entry types.
1014            *
1015            * @return the document library file entry types
1016            */
1017            public static List<DLFileEntryType> findAll() {
1018                    return getPersistence().findAll();
1019            }
1020    
1021            /**
1022            * Returns a range of all the document library file entry types.
1023            *
1024            * <p>
1025            * 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 DLFileEntryTypeModelImpl}. 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.
1026            * </p>
1027            *
1028            * @param start the lower bound of the range of document library file entry types
1029            * @param end the upper bound of the range of document library file entry types (not inclusive)
1030            * @return the range of document library file entry types
1031            */
1032            public static List<DLFileEntryType> findAll(int start, int end) {
1033                    return getPersistence().findAll(start, end);
1034            }
1035    
1036            /**
1037            * Returns an ordered range of all the document library file entry types.
1038            *
1039            * <p>
1040            * 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 DLFileEntryTypeModelImpl}. 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.
1041            * </p>
1042            *
1043            * @param start the lower bound of the range of document library file entry types
1044            * @param end the upper bound of the range of document library file entry types (not inclusive)
1045            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1046            * @return the ordered range of document library file entry types
1047            */
1048            public static List<DLFileEntryType> findAll(int start, int end,
1049                    OrderByComparator<DLFileEntryType> orderByComparator) {
1050                    return getPersistence().findAll(start, end, orderByComparator);
1051            }
1052    
1053            /**
1054            * Returns an ordered range of all the document library file entry types.
1055            *
1056            * <p>
1057            * 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 DLFileEntryTypeModelImpl}. 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.
1058            * </p>
1059            *
1060            * @param start the lower bound of the range of document library file entry types
1061            * @param end the upper bound of the range of document library file entry types (not inclusive)
1062            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1063            * @param retrieveFromCache whether to retrieve from the finder cache
1064            * @return the ordered range of document library file entry types
1065            */
1066            public static List<DLFileEntryType> findAll(int start, int end,
1067                    OrderByComparator<DLFileEntryType> orderByComparator,
1068                    boolean retrieveFromCache) {
1069                    return getPersistence()
1070                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1071            }
1072    
1073            /**
1074            * Removes all the document library file entry types from the database.
1075            */
1076            public static void removeAll() {
1077                    getPersistence().removeAll();
1078            }
1079    
1080            /**
1081            * Returns the number of document library file entry types.
1082            *
1083            * @return the number of document library file entry types
1084            */
1085            public static int countAll() {
1086                    return getPersistence().countAll();
1087            }
1088    
1089            /**
1090            * Returns the primaryKeys of document library folders associated with the document library file entry type.
1091            *
1092            * @param pk the primary key of the document library file entry type
1093            * @return long[] of the primaryKeys of document library folders associated with the document library file entry type
1094            */
1095            public static long[] getDLFolderPrimaryKeys(long pk) {
1096                    return getPersistence().getDLFolderPrimaryKeys(pk);
1097            }
1098    
1099            /**
1100            * Returns all the document library folders associated with the document library file entry type.
1101            *
1102            * @param pk the primary key of the document library file entry type
1103            * @return the document library folders associated with the document library file entry type
1104            */
1105            public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders(
1106                    long pk) {
1107                    return getPersistence().getDLFolders(pk);
1108            }
1109    
1110            /**
1111            * Returns a range of all the document library folders associated with the document library file entry type.
1112            *
1113            * <p>
1114            * 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 DLFileEntryTypeModelImpl}. 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.
1115            * </p>
1116            *
1117            * @param pk the primary key of the document library file entry type
1118            * @param start the lower bound of the range of document library file entry types
1119            * @param end the upper bound of the range of document library file entry types (not inclusive)
1120            * @return the range of document library folders associated with the document library file entry type
1121            */
1122            public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders(
1123                    long pk, int start, int end) {
1124                    return getPersistence().getDLFolders(pk, start, end);
1125            }
1126    
1127            /**
1128            * Returns an ordered range of all the document library folders associated with the document library file entry type.
1129            *
1130            * <p>
1131            * 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 DLFileEntryTypeModelImpl}. 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.
1132            * </p>
1133            *
1134            * @param pk the primary key of the document library file entry type
1135            * @param start the lower bound of the range of document library file entry types
1136            * @param end the upper bound of the range of document library file entry types (not inclusive)
1137            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1138            * @return the ordered range of document library folders associated with the document library file entry type
1139            */
1140            public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders(
1141                    long pk, int start, int end,
1142                    OrderByComparator<com.liferay.portlet.documentlibrary.model.DLFolder> orderByComparator) {
1143                    return getPersistence().getDLFolders(pk, start, end, orderByComparator);
1144            }
1145    
1146            /**
1147            * Returns the number of document library folders associated with the document library file entry type.
1148            *
1149            * @param pk the primary key of the document library file entry type
1150            * @return the number of document library folders associated with the document library file entry type
1151            */
1152            public static int getDLFoldersSize(long pk) {
1153                    return getPersistence().getDLFoldersSize(pk);
1154            }
1155    
1156            /**
1157            * Returns <code>true</code> if the document library folder is associated with the document library file entry type.
1158            *
1159            * @param pk the primary key of the document library file entry type
1160            * @param dlFolderPK the primary key of the document library folder
1161            * @return <code>true</code> if the document library folder is associated with the document library file entry type; <code>false</code> otherwise
1162            */
1163            public static boolean containsDLFolder(long pk, long dlFolderPK) {
1164                    return getPersistence().containsDLFolder(pk, dlFolderPK);
1165            }
1166    
1167            /**
1168            * Returns <code>true</code> if the document library file entry type has any document library folders associated with it.
1169            *
1170            * @param pk the primary key of the document library file entry type to check for associations with document library folders
1171            * @return <code>true</code> if the document library file entry type has any document library folders associated with it; <code>false</code> otherwise
1172            */
1173            public static boolean containsDLFolders(long pk) {
1174                    return getPersistence().containsDLFolders(pk);
1175            }
1176    
1177            /**
1178            * Adds an association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1179            *
1180            * @param pk the primary key of the document library file entry type
1181            * @param dlFolderPK the primary key of the document library folder
1182            */
1183            public static void addDLFolder(long pk, long dlFolderPK) {
1184                    getPersistence().addDLFolder(pk, dlFolderPK);
1185            }
1186    
1187            /**
1188            * Adds an association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1189            *
1190            * @param pk the primary key of the document library file entry type
1191            * @param dlFolder the document library folder
1192            */
1193            public static void addDLFolder(long pk,
1194                    com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) {
1195                    getPersistence().addDLFolder(pk, dlFolder);
1196            }
1197    
1198            /**
1199            * Adds an association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1200            *
1201            * @param pk the primary key of the document library file entry type
1202            * @param dlFolderPKs the primary keys of the document library folders
1203            */
1204            public static void addDLFolders(long pk, long[] dlFolderPKs) {
1205                    getPersistence().addDLFolders(pk, dlFolderPKs);
1206            }
1207    
1208            /**
1209            * Adds an association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1210            *
1211            * @param pk the primary key of the document library file entry type
1212            * @param dlFolders the document library folders
1213            */
1214            public static void addDLFolders(long pk,
1215                    List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) {
1216                    getPersistence().addDLFolders(pk, dlFolders);
1217            }
1218    
1219            /**
1220            * Clears all associations between the document library file entry type and its document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1221            *
1222            * @param pk the primary key of the document library file entry type to clear the associated document library folders from
1223            */
1224            public static void clearDLFolders(long pk) {
1225                    getPersistence().clearDLFolders(pk);
1226            }
1227    
1228            /**
1229            * Removes the association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1230            *
1231            * @param pk the primary key of the document library file entry type
1232            * @param dlFolderPK the primary key of the document library folder
1233            */
1234            public static void removeDLFolder(long pk, long dlFolderPK) {
1235                    getPersistence().removeDLFolder(pk, dlFolderPK);
1236            }
1237    
1238            /**
1239            * Removes the association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1240            *
1241            * @param pk the primary key of the document library file entry type
1242            * @param dlFolder the document library folder
1243            */
1244            public static void removeDLFolder(long pk,
1245                    com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) {
1246                    getPersistence().removeDLFolder(pk, dlFolder);
1247            }
1248    
1249            /**
1250            * Removes the association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1251            *
1252            * @param pk the primary key of the document library file entry type
1253            * @param dlFolderPKs the primary keys of the document library folders
1254            */
1255            public static void removeDLFolders(long pk, long[] dlFolderPKs) {
1256                    getPersistence().removeDLFolders(pk, dlFolderPKs);
1257            }
1258    
1259            /**
1260            * Removes the association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1261            *
1262            * @param pk the primary key of the document library file entry type
1263            * @param dlFolders the document library folders
1264            */
1265            public static void removeDLFolders(long pk,
1266                    List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) {
1267                    getPersistence().removeDLFolders(pk, dlFolders);
1268            }
1269    
1270            /**
1271            * Sets the document library folders associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1272            *
1273            * @param pk the primary key of the document library file entry type
1274            * @param dlFolderPKs the primary keys of the document library folders to be associated with the document library file entry type
1275            */
1276            public static void setDLFolders(long pk, long[] dlFolderPKs) {
1277                    getPersistence().setDLFolders(pk, dlFolderPKs);
1278            }
1279    
1280            /**
1281            * Sets the document library folders associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1282            *
1283            * @param pk the primary key of the document library file entry type
1284            * @param dlFolders the document library folders to be associated with the document library file entry type
1285            */
1286            public static void setDLFolders(long pk,
1287                    List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) {
1288                    getPersistence().setDLFolders(pk, dlFolders);
1289            }
1290    
1291            public static java.util.Set<java.lang.String> getBadColumnNames() {
1292                    return getPersistence().getBadColumnNames();
1293            }
1294    
1295            public static DLFileEntryTypePersistence getPersistence() {
1296                    if (_persistence == null) {
1297                            _persistence = (DLFileEntryTypePersistence)PortalBeanLocatorUtil.locate(DLFileEntryTypePersistence.class.getName());
1298    
1299                            ReferenceRegistry.registerReference(DLFileEntryTypeUtil.class,
1300                                    "_persistence");
1301                    }
1302    
1303                    return _persistence;
1304            }
1305    
1306            private static DLFileEntryTypePersistence _persistence;
1307    }