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