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 the first user notification event in the ordered set where uuid = &#63;.
161            *
162            * @param uuid the uuid
163            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
164            * @return the first matching user notification event
165            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
166            */
167            public static UserNotificationEvent findByUuid_First(
168                    java.lang.String uuid,
169                    OrderByComparator<UserNotificationEvent> orderByComparator)
170                    throws com.liferay.portal.NoSuchUserNotificationEventException {
171                    return getPersistence().findByUuid_First(uuid, orderByComparator);
172            }
173    
174            /**
175            * Returns the first user notification event in the ordered set where uuid = &#63;.
176            *
177            * @param uuid the uuid
178            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
179            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
180            */
181            public static UserNotificationEvent fetchByUuid_First(
182                    java.lang.String uuid,
183                    OrderByComparator<UserNotificationEvent> orderByComparator) {
184                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
185            }
186    
187            /**
188            * Returns the last user notification event in the ordered set where uuid = &#63;.
189            *
190            * @param uuid the uuid
191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
192            * @return the last matching user notification event
193            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
194            */
195            public static UserNotificationEvent findByUuid_Last(java.lang.String uuid,
196                    OrderByComparator<UserNotificationEvent> orderByComparator)
197                    throws com.liferay.portal.NoSuchUserNotificationEventException {
198                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
199            }
200    
201            /**
202            * Returns the last user notification event in the ordered set where uuid = &#63;.
203            *
204            * @param uuid the uuid
205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
206            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
207            */
208            public static UserNotificationEvent fetchByUuid_Last(
209                    java.lang.String uuid,
210                    OrderByComparator<UserNotificationEvent> orderByComparator) {
211                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
212            }
213    
214            /**
215            * Returns the user notification events before and after the current user notification event in the ordered set where uuid = &#63;.
216            *
217            * @param userNotificationEventId the primary key of the current user notification event
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the previous, current, and next user notification event
221            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
222            */
223            public static UserNotificationEvent[] findByUuid_PrevAndNext(
224                    long userNotificationEventId, java.lang.String uuid,
225                    OrderByComparator<UserNotificationEvent> orderByComparator)
226                    throws com.liferay.portal.NoSuchUserNotificationEventException {
227                    return getPersistence()
228                                       .findByUuid_PrevAndNext(userNotificationEventId, uuid,
229                            orderByComparator);
230            }
231    
232            /**
233            * Removes all the user notification events where uuid = &#63; from the database.
234            *
235            * @param uuid the uuid
236            */
237            public static void removeByUuid(java.lang.String uuid) {
238                    getPersistence().removeByUuid(uuid);
239            }
240    
241            /**
242            * Returns the number of user notification events where uuid = &#63;.
243            *
244            * @param uuid the uuid
245            * @return the number of matching user notification events
246            */
247            public static int countByUuid(java.lang.String uuid) {
248                    return getPersistence().countByUuid(uuid);
249            }
250    
251            /**
252            * Returns all the user notification events where uuid = &#63; and companyId = &#63;.
253            *
254            * @param uuid the uuid
255            * @param companyId the company ID
256            * @return the matching user notification events
257            */
258            public static List<UserNotificationEvent> findByUuid_C(
259                    java.lang.String uuid, long companyId) {
260                    return getPersistence().findByUuid_C(uuid, companyId);
261            }
262    
263            /**
264            * Returns a range of all the user notification events where uuid = &#63; and companyId = &#63;.
265            *
266            * <p>
267            * 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.
268            * </p>
269            *
270            * @param uuid the uuid
271            * @param companyId the company ID
272            * @param start the lower bound of the range of user notification events
273            * @param end the upper bound of the range of user notification events (not inclusive)
274            * @return the range of matching user notification events
275            */
276            public static List<UserNotificationEvent> findByUuid_C(
277                    java.lang.String uuid, long companyId, int start, int end) {
278                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
279            }
280    
281            /**
282            * Returns an ordered range of all the user notification events where uuid = &#63; and companyId = &#63;.
283            *
284            * <p>
285            * 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.
286            * </p>
287            *
288            * @param uuid the uuid
289            * @param companyId the company ID
290            * @param start the lower bound of the range of user notification events
291            * @param end the upper bound of the range of user notification events (not inclusive)
292            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
293            * @return the ordered range of matching user notification events
294            */
295            public static List<UserNotificationEvent> findByUuid_C(
296                    java.lang.String uuid, long companyId, int start, int end,
297                    OrderByComparator<UserNotificationEvent> orderByComparator) {
298                    return getPersistence()
299                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
300            }
301    
302            /**
303            * Returns the first user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
304            *
305            * @param uuid the uuid
306            * @param companyId the company ID
307            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
308            * @return the first matching user notification event
309            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
310            */
311            public static UserNotificationEvent findByUuid_C_First(
312                    java.lang.String uuid, long companyId,
313                    OrderByComparator<UserNotificationEvent> orderByComparator)
314                    throws com.liferay.portal.NoSuchUserNotificationEventException {
315                    return getPersistence()
316                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
317            }
318    
319            /**
320            * Returns the first user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
321            *
322            * @param uuid the uuid
323            * @param companyId the company ID
324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
325            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
326            */
327            public static UserNotificationEvent fetchByUuid_C_First(
328                    java.lang.String uuid, long companyId,
329                    OrderByComparator<UserNotificationEvent> orderByComparator) {
330                    return getPersistence()
331                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
332            }
333    
334            /**
335            * Returns the last user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
336            *
337            * @param uuid the uuid
338            * @param companyId the company ID
339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
340            * @return the last matching user notification event
341            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
342            */
343            public static UserNotificationEvent findByUuid_C_Last(
344                    java.lang.String uuid, long companyId,
345                    OrderByComparator<UserNotificationEvent> orderByComparator)
346                    throws com.liferay.portal.NoSuchUserNotificationEventException {
347                    return getPersistence()
348                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
349            }
350    
351            /**
352            * Returns the last user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
353            *
354            * @param uuid the uuid
355            * @param companyId the company ID
356            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
357            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
358            */
359            public static UserNotificationEvent fetchByUuid_C_Last(
360                    java.lang.String uuid, long companyId,
361                    OrderByComparator<UserNotificationEvent> orderByComparator) {
362                    return getPersistence()
363                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
364            }
365    
366            /**
367            * Returns the user notification events before and after the current user notification event in the ordered set where uuid = &#63; and companyId = &#63;.
368            *
369            * @param userNotificationEventId the primary key of the current user notification event
370            * @param uuid the uuid
371            * @param companyId the company ID
372            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
373            * @return the previous, current, and next user notification event
374            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
375            */
376            public static UserNotificationEvent[] findByUuid_C_PrevAndNext(
377                    long userNotificationEventId, java.lang.String uuid, long companyId,
378                    OrderByComparator<UserNotificationEvent> orderByComparator)
379                    throws com.liferay.portal.NoSuchUserNotificationEventException {
380                    return getPersistence()
381                                       .findByUuid_C_PrevAndNext(userNotificationEventId, uuid,
382                            companyId, orderByComparator);
383            }
384    
385            /**
386            * Removes all the user notification events where uuid = &#63; and companyId = &#63; from the database.
387            *
388            * @param uuid the uuid
389            * @param companyId the company ID
390            */
391            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
392                    getPersistence().removeByUuid_C(uuid, companyId);
393            }
394    
395            /**
396            * Returns the number of user notification events where uuid = &#63; and companyId = &#63;.
397            *
398            * @param uuid the uuid
399            * @param companyId the company ID
400            * @return the number of matching user notification events
401            */
402            public static int countByUuid_C(java.lang.String uuid, long companyId) {
403                    return getPersistence().countByUuid_C(uuid, companyId);
404            }
405    
406            /**
407            * Returns all the user notification events where userId = &#63;.
408            *
409            * @param userId the user ID
410            * @return the matching user notification events
411            */
412            public static List<UserNotificationEvent> findByUserId(long userId) {
413                    return getPersistence().findByUserId(userId);
414            }
415    
416            /**
417            * Returns a range of all the user notification events where userId = &#63;.
418            *
419            * <p>
420            * 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.
421            * </p>
422            *
423            * @param userId the user ID
424            * @param start the lower bound of the range of user notification events
425            * @param end the upper bound of the range of user notification events (not inclusive)
426            * @return the range of matching user notification events
427            */
428            public static List<UserNotificationEvent> findByUserId(long userId,
429                    int start, int end) {
430                    return getPersistence().findByUserId(userId, start, end);
431            }
432    
433            /**
434            * Returns an ordered range of all the user notification events where userId = &#63;.
435            *
436            * <p>
437            * 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.
438            * </p>
439            *
440            * @param userId the user ID
441            * @param start the lower bound of the range of user notification events
442            * @param end the upper bound of the range of user notification events (not inclusive)
443            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
444            * @return the ordered range of matching user notification events
445            */
446            public static List<UserNotificationEvent> findByUserId(long userId,
447                    int start, int end,
448                    OrderByComparator<UserNotificationEvent> orderByComparator) {
449                    return getPersistence()
450                                       .findByUserId(userId, start, end, orderByComparator);
451            }
452    
453            /**
454            * Returns the first user notification event in the ordered set where userId = &#63;.
455            *
456            * @param userId the user ID
457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
458            * @return the first matching user notification event
459            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
460            */
461            public static UserNotificationEvent findByUserId_First(long userId,
462                    OrderByComparator<UserNotificationEvent> orderByComparator)
463                    throws com.liferay.portal.NoSuchUserNotificationEventException {
464                    return getPersistence().findByUserId_First(userId, orderByComparator);
465            }
466    
467            /**
468            * Returns the first user notification event in the ordered set where userId = &#63;.
469            *
470            * @param userId the user ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
473            */
474            public static UserNotificationEvent fetchByUserId_First(long userId,
475                    OrderByComparator<UserNotificationEvent> orderByComparator) {
476                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
477            }
478    
479            /**
480            * Returns the last user notification event in the ordered set where userId = &#63;.
481            *
482            * @param userId the user ID
483            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
484            * @return the last matching user notification event
485            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
486            */
487            public static UserNotificationEvent findByUserId_Last(long userId,
488                    OrderByComparator<UserNotificationEvent> orderByComparator)
489                    throws com.liferay.portal.NoSuchUserNotificationEventException {
490                    return getPersistence().findByUserId_Last(userId, orderByComparator);
491            }
492    
493            /**
494            * Returns the last user notification event in the ordered set where userId = &#63;.
495            *
496            * @param userId the user ID
497            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
498            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
499            */
500            public static UserNotificationEvent fetchByUserId_Last(long userId,
501                    OrderByComparator<UserNotificationEvent> orderByComparator) {
502                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
503            }
504    
505            /**
506            * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63;.
507            *
508            * @param userNotificationEventId the primary key of the current user notification event
509            * @param userId the user ID
510            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
511            * @return the previous, current, and next user notification event
512            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
513            */
514            public static UserNotificationEvent[] findByUserId_PrevAndNext(
515                    long userNotificationEventId, long userId,
516                    OrderByComparator<UserNotificationEvent> orderByComparator)
517                    throws com.liferay.portal.NoSuchUserNotificationEventException {
518                    return getPersistence()
519                                       .findByUserId_PrevAndNext(userNotificationEventId, userId,
520                            orderByComparator);
521            }
522    
523            /**
524            * Removes all the user notification events where userId = &#63; from the database.
525            *
526            * @param userId the user ID
527            */
528            public static void removeByUserId(long userId) {
529                    getPersistence().removeByUserId(userId);
530            }
531    
532            /**
533            * Returns the number of user notification events where userId = &#63;.
534            *
535            * @param userId the user ID
536            * @return the number of matching user notification events
537            */
538            public static int countByUserId(long userId) {
539                    return getPersistence().countByUserId(userId);
540            }
541    
542            /**
543            * Returns all the user notification events where userId = &#63; and deliveryType = &#63;.
544            *
545            * @param userId the user ID
546            * @param deliveryType the delivery type
547            * @return the matching user notification events
548            */
549            public static List<UserNotificationEvent> findByU_DT(long userId,
550                    int deliveryType) {
551                    return getPersistence().findByU_DT(userId, deliveryType);
552            }
553    
554            /**
555            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63;.
556            *
557            * <p>
558            * 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.
559            * </p>
560            *
561            * @param userId the user ID
562            * @param deliveryType the delivery type
563            * @param start the lower bound of the range of user notification events
564            * @param end the upper bound of the range of user notification events (not inclusive)
565            * @return the range of matching user notification events
566            */
567            public static List<UserNotificationEvent> findByU_DT(long userId,
568                    int deliveryType, int start, int end) {
569                    return getPersistence().findByU_DT(userId, deliveryType, start, end);
570            }
571    
572            /**
573            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63;.
574            *
575            * <p>
576            * 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.
577            * </p>
578            *
579            * @param userId the user ID
580            * @param deliveryType the delivery type
581            * @param start the lower bound of the range of user notification events
582            * @param end the upper bound of the range of user notification events (not inclusive)
583            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
584            * @return the ordered range of matching user notification events
585            */
586            public static List<UserNotificationEvent> findByU_DT(long userId,
587                    int deliveryType, int start, int end,
588                    OrderByComparator<UserNotificationEvent> orderByComparator) {
589                    return getPersistence()
590                                       .findByU_DT(userId, deliveryType, start, end,
591                            orderByComparator);
592            }
593    
594            /**
595            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
596            *
597            * @param userId the user ID
598            * @param deliveryType the delivery type
599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
600            * @return the first matching user notification event
601            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
602            */
603            public static UserNotificationEvent findByU_DT_First(long userId,
604                    int deliveryType,
605                    OrderByComparator<UserNotificationEvent> orderByComparator)
606                    throws com.liferay.portal.NoSuchUserNotificationEventException {
607                    return getPersistence()
608                                       .findByU_DT_First(userId, deliveryType, orderByComparator);
609            }
610    
611            /**
612            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
613            *
614            * @param userId the user ID
615            * @param deliveryType the delivery type
616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
617            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
618            */
619            public static UserNotificationEvent fetchByU_DT_First(long userId,
620                    int deliveryType,
621                    OrderByComparator<UserNotificationEvent> orderByComparator) {
622                    return getPersistence()
623                                       .fetchByU_DT_First(userId, deliveryType, orderByComparator);
624            }
625    
626            /**
627            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
628            *
629            * @param userId the user ID
630            * @param deliveryType the delivery type
631            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
632            * @return the last matching user notification event
633            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
634            */
635            public static UserNotificationEvent findByU_DT_Last(long userId,
636                    int deliveryType,
637                    OrderByComparator<UserNotificationEvent> orderByComparator)
638                    throws com.liferay.portal.NoSuchUserNotificationEventException {
639                    return getPersistence()
640                                       .findByU_DT_Last(userId, deliveryType, orderByComparator);
641            }
642    
643            /**
644            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
645            *
646            * @param userId the user ID
647            * @param deliveryType the delivery type
648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
649            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
650            */
651            public static UserNotificationEvent fetchByU_DT_Last(long userId,
652                    int deliveryType,
653                    OrderByComparator<UserNotificationEvent> orderByComparator) {
654                    return getPersistence()
655                                       .fetchByU_DT_Last(userId, deliveryType, orderByComparator);
656            }
657    
658            /**
659            * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
660            *
661            * @param userNotificationEventId the primary key of the current user notification event
662            * @param userId the user ID
663            * @param deliveryType the delivery type
664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
665            * @return the previous, current, and next user notification event
666            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
667            */
668            public static UserNotificationEvent[] findByU_DT_PrevAndNext(
669                    long userNotificationEventId, long userId, int deliveryType,
670                    OrderByComparator<UserNotificationEvent> orderByComparator)
671                    throws com.liferay.portal.NoSuchUserNotificationEventException {
672                    return getPersistence()
673                                       .findByU_DT_PrevAndNext(userNotificationEventId, userId,
674                            deliveryType, orderByComparator);
675            }
676    
677            /**
678            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; from the database.
679            *
680            * @param userId the user ID
681            * @param deliveryType the delivery type
682            */
683            public static void removeByU_DT(long userId, int deliveryType) {
684                    getPersistence().removeByU_DT(userId, deliveryType);
685            }
686    
687            /**
688            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63;.
689            *
690            * @param userId the user ID
691            * @param deliveryType the delivery type
692            * @return the number of matching user notification events
693            */
694            public static int countByU_DT(long userId, int deliveryType) {
695                    return getPersistence().countByU_DT(userId, deliveryType);
696            }
697    
698            /**
699            * Returns all the user notification events where userId = &#63; and delivered = &#63;.
700            *
701            * @param userId the user ID
702            * @param delivered the delivered
703            * @return the matching user notification events
704            */
705            public static List<UserNotificationEvent> findByU_D(long userId,
706                    boolean delivered) {
707                    return getPersistence().findByU_D(userId, delivered);
708            }
709    
710            /**
711            * Returns a range of all the user notification events where userId = &#63; and delivered = &#63;.
712            *
713            * <p>
714            * 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.
715            * </p>
716            *
717            * @param userId the user ID
718            * @param delivered the delivered
719            * @param start the lower bound of the range of user notification events
720            * @param end the upper bound of the range of user notification events (not inclusive)
721            * @return the range of matching user notification events
722            */
723            public static List<UserNotificationEvent> findByU_D(long userId,
724                    boolean delivered, int start, int end) {
725                    return getPersistence().findByU_D(userId, delivered, start, end);
726            }
727    
728            /**
729            * Returns an ordered range of all the user notification events where userId = &#63; and delivered = &#63;.
730            *
731            * <p>
732            * 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.
733            * </p>
734            *
735            * @param userId the user ID
736            * @param delivered the delivered
737            * @param start the lower bound of the range of user notification events
738            * @param end the upper bound of the range of user notification events (not inclusive)
739            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
740            * @return the ordered range of matching user notification events
741            */
742            public static List<UserNotificationEvent> findByU_D(long userId,
743                    boolean delivered, int start, int end,
744                    OrderByComparator<UserNotificationEvent> orderByComparator) {
745                    return getPersistence()
746                                       .findByU_D(userId, delivered, start, end, orderByComparator);
747            }
748    
749            /**
750            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63;.
751            *
752            * @param userId the user ID
753            * @param delivered the delivered
754            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
755            * @return the first matching user notification event
756            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
757            */
758            public static UserNotificationEvent findByU_D_First(long userId,
759                    boolean delivered,
760                    OrderByComparator<UserNotificationEvent> orderByComparator)
761                    throws com.liferay.portal.NoSuchUserNotificationEventException {
762                    return getPersistence()
763                                       .findByU_D_First(userId, delivered, orderByComparator);
764            }
765    
766            /**
767            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63;.
768            *
769            * @param userId the user ID
770            * @param delivered the delivered
771            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
772            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
773            */
774            public static UserNotificationEvent fetchByU_D_First(long userId,
775                    boolean delivered,
776                    OrderByComparator<UserNotificationEvent> orderByComparator) {
777                    return getPersistence()
778                                       .fetchByU_D_First(userId, delivered, orderByComparator);
779            }
780    
781            /**
782            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63;.
783            *
784            * @param userId the user ID
785            * @param delivered the delivered
786            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
787            * @return the last matching user notification event
788            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
789            */
790            public static UserNotificationEvent findByU_D_Last(long userId,
791                    boolean delivered,
792                    OrderByComparator<UserNotificationEvent> orderByComparator)
793                    throws com.liferay.portal.NoSuchUserNotificationEventException {
794                    return getPersistence()
795                                       .findByU_D_Last(userId, delivered, orderByComparator);
796            }
797    
798            /**
799            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63;.
800            *
801            * @param userId the user ID
802            * @param delivered the delivered
803            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
804            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
805            */
806            public static UserNotificationEvent fetchByU_D_Last(long userId,
807                    boolean delivered,
808                    OrderByComparator<UserNotificationEvent> orderByComparator) {
809                    return getPersistence()
810                                       .fetchByU_D_Last(userId, delivered, orderByComparator);
811            }
812    
813            /**
814            * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and delivered = &#63;.
815            *
816            * @param userNotificationEventId the primary key of the current user notification event
817            * @param userId the user ID
818            * @param delivered the delivered
819            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
820            * @return the previous, current, and next user notification event
821            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
822            */
823            public static UserNotificationEvent[] findByU_D_PrevAndNext(
824                    long userNotificationEventId, long userId, boolean delivered,
825                    OrderByComparator<UserNotificationEvent> orderByComparator)
826                    throws com.liferay.portal.NoSuchUserNotificationEventException {
827                    return getPersistence()
828                                       .findByU_D_PrevAndNext(userNotificationEventId, userId,
829                            delivered, orderByComparator);
830            }
831    
832            /**
833            * Removes all the user notification events where userId = &#63; and delivered = &#63; from the database.
834            *
835            * @param userId the user ID
836            * @param delivered the delivered
837            */
838            public static void removeByU_D(long userId, boolean delivered) {
839                    getPersistence().removeByU_D(userId, delivered);
840            }
841    
842            /**
843            * Returns the number of user notification events where userId = &#63; and delivered = &#63;.
844            *
845            * @param userId the user ID
846            * @param delivered the delivered
847            * @return the number of matching user notification events
848            */
849            public static int countByU_D(long userId, boolean delivered) {
850                    return getPersistence().countByU_D(userId, delivered);
851            }
852    
853            /**
854            * Returns all the user notification events where userId = &#63; and archived = &#63;.
855            *
856            * @param userId the user ID
857            * @param archived the archived
858            * @return the matching user notification events
859            */
860            public static List<UserNotificationEvent> findByU_A(long userId,
861                    boolean archived) {
862                    return getPersistence().findByU_A(userId, archived);
863            }
864    
865            /**
866            * Returns a range of all the user notification events where userId = &#63; and archived = &#63;.
867            *
868            * <p>
869            * 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.
870            * </p>
871            *
872            * @param userId the user ID
873            * @param archived the archived
874            * @param start the lower bound of the range of user notification events
875            * @param end the upper bound of the range of user notification events (not inclusive)
876            * @return the range of matching user notification events
877            */
878            public static List<UserNotificationEvent> findByU_A(long userId,
879                    boolean archived, int start, int end) {
880                    return getPersistence().findByU_A(userId, archived, start, end);
881            }
882    
883            /**
884            * Returns an ordered range of all the user notification events where userId = &#63; and archived = &#63;.
885            *
886            * <p>
887            * 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.
888            * </p>
889            *
890            * @param userId the user ID
891            * @param archived the archived
892            * @param start the lower bound of the range of user notification events
893            * @param end the upper bound of the range of user notification events (not inclusive)
894            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
895            * @return the ordered range of matching user notification events
896            */
897            public static List<UserNotificationEvent> findByU_A(long userId,
898                    boolean archived, int start, int end,
899                    OrderByComparator<UserNotificationEvent> orderByComparator) {
900                    return getPersistence()
901                                       .findByU_A(userId, archived, start, end, orderByComparator);
902            }
903    
904            /**
905            * Returns the first user notification event in the ordered set where userId = &#63; and archived = &#63;.
906            *
907            * @param userId the user ID
908            * @param archived the archived
909            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
910            * @return the first matching user notification event
911            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
912            */
913            public static UserNotificationEvent findByU_A_First(long userId,
914                    boolean archived,
915                    OrderByComparator<UserNotificationEvent> orderByComparator)
916                    throws com.liferay.portal.NoSuchUserNotificationEventException {
917                    return getPersistence()
918                                       .findByU_A_First(userId, archived, orderByComparator);
919            }
920    
921            /**
922            * Returns the first user notification event in the ordered set where userId = &#63; and archived = &#63;.
923            *
924            * @param userId the user ID
925            * @param archived the archived
926            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
927            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
928            */
929            public static UserNotificationEvent fetchByU_A_First(long userId,
930                    boolean archived,
931                    OrderByComparator<UserNotificationEvent> orderByComparator) {
932                    return getPersistence()
933                                       .fetchByU_A_First(userId, archived, orderByComparator);
934            }
935    
936            /**
937            * Returns the last user notification event in the ordered set where userId = &#63; and archived = &#63;.
938            *
939            * @param userId the user ID
940            * @param archived the archived
941            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
942            * @return the last matching user notification event
943            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
944            */
945            public static UserNotificationEvent findByU_A_Last(long userId,
946                    boolean archived,
947                    OrderByComparator<UserNotificationEvent> orderByComparator)
948                    throws com.liferay.portal.NoSuchUserNotificationEventException {
949                    return getPersistence()
950                                       .findByU_A_Last(userId, archived, orderByComparator);
951            }
952    
953            /**
954            * Returns the last user notification event in the ordered set where userId = &#63; and archived = &#63;.
955            *
956            * @param userId the user ID
957            * @param archived the archived
958            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
959            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
960            */
961            public static UserNotificationEvent fetchByU_A_Last(long userId,
962                    boolean archived,
963                    OrderByComparator<UserNotificationEvent> orderByComparator) {
964                    return getPersistence()
965                                       .fetchByU_A_Last(userId, archived, orderByComparator);
966            }
967    
968            /**
969            * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and archived = &#63;.
970            *
971            * @param userNotificationEventId the primary key of the current user notification event
972            * @param userId the user ID
973            * @param archived the archived
974            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
975            * @return the previous, current, and next user notification event
976            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
977            */
978            public static UserNotificationEvent[] findByU_A_PrevAndNext(
979                    long userNotificationEventId, long userId, boolean archived,
980                    OrderByComparator<UserNotificationEvent> orderByComparator)
981                    throws com.liferay.portal.NoSuchUserNotificationEventException {
982                    return getPersistence()
983                                       .findByU_A_PrevAndNext(userNotificationEventId, userId,
984                            archived, orderByComparator);
985            }
986    
987            /**
988            * Removes all the user notification events where userId = &#63; and archived = &#63; from the database.
989            *
990            * @param userId the user ID
991            * @param archived the archived
992            */
993            public static void removeByU_A(long userId, boolean archived) {
994                    getPersistence().removeByU_A(userId, archived);
995            }
996    
997            /**
998            * Returns the number of user notification events where userId = &#63; and archived = &#63;.
999            *
1000            * @param userId the user ID
1001            * @param archived the archived
1002            * @return the number of matching user notification events
1003            */
1004            public static int countByU_A(long userId, boolean archived) {
1005                    return getPersistence().countByU_A(userId, archived);
1006            }
1007    
1008            /**
1009            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1010            *
1011            * @param userId the user ID
1012            * @param deliveryType the delivery type
1013            * @param delivered the delivered
1014            * @return the matching user notification events
1015            */
1016            public static List<UserNotificationEvent> findByU_DT_D(long userId,
1017                    int deliveryType, boolean delivered) {
1018                    return getPersistence().findByU_DT_D(userId, deliveryType, delivered);
1019            }
1020    
1021            /**
1022            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1023            *
1024            * <p>
1025            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1026            * </p>
1027            *
1028            * @param userId the user ID
1029            * @param deliveryType the delivery type
1030            * @param delivered the delivered
1031            * @param start the lower bound of the range of user notification events
1032            * @param end the upper bound of the range of user notification events (not inclusive)
1033            * @return the range of matching user notification events
1034            */
1035            public static List<UserNotificationEvent> findByU_DT_D(long userId,
1036                    int deliveryType, boolean delivered, int start, int end) {
1037                    return getPersistence()
1038                                       .findByU_DT_D(userId, deliveryType, delivered, start, end);
1039            }
1040    
1041            /**
1042            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1043            *
1044            * <p>
1045            * 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.
1046            * </p>
1047            *
1048            * @param userId the user ID
1049            * @param deliveryType the delivery type
1050            * @param delivered the delivered
1051            * @param start the lower bound of the range of user notification events
1052            * @param end the upper bound of the range of user notification events (not inclusive)
1053            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1054            * @return the ordered range of matching user notification events
1055            */
1056            public static List<UserNotificationEvent> findByU_DT_D(long userId,
1057                    int deliveryType, boolean delivered, int start, int end,
1058                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1059                    return getPersistence()
1060                                       .findByU_DT_D(userId, deliveryType, delivered, start, end,
1061                            orderByComparator);
1062            }
1063    
1064            /**
1065            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1066            *
1067            * @param userId the user ID
1068            * @param deliveryType the delivery type
1069            * @param delivered the delivered
1070            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1071            * @return the first matching user notification event
1072            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1073            */
1074            public static UserNotificationEvent findByU_DT_D_First(long userId,
1075                    int deliveryType, boolean delivered,
1076                    OrderByComparator<UserNotificationEvent> orderByComparator)
1077                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1078                    return getPersistence()
1079                                       .findByU_DT_D_First(userId, deliveryType, delivered,
1080                            orderByComparator);
1081            }
1082    
1083            /**
1084            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1085            *
1086            * @param userId the user ID
1087            * @param deliveryType the delivery type
1088            * @param delivered the delivered
1089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1090            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1091            */
1092            public static UserNotificationEvent fetchByU_DT_D_First(long userId,
1093                    int deliveryType, boolean delivered,
1094                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1095                    return getPersistence()
1096                                       .fetchByU_DT_D_First(userId, deliveryType, delivered,
1097                            orderByComparator);
1098            }
1099    
1100            /**
1101            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1102            *
1103            * @param userId the user ID
1104            * @param deliveryType the delivery type
1105            * @param delivered the delivered
1106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1107            * @return the last matching user notification event
1108            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1109            */
1110            public static UserNotificationEvent findByU_DT_D_Last(long userId,
1111                    int deliveryType, boolean delivered,
1112                    OrderByComparator<UserNotificationEvent> orderByComparator)
1113                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1114                    return getPersistence()
1115                                       .findByU_DT_D_Last(userId, deliveryType, delivered,
1116                            orderByComparator);
1117            }
1118    
1119            /**
1120            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1121            *
1122            * @param userId the user ID
1123            * @param deliveryType the delivery type
1124            * @param delivered the delivered
1125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1126            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1127            */
1128            public static UserNotificationEvent fetchByU_DT_D_Last(long userId,
1129                    int deliveryType, boolean delivered,
1130                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1131                    return getPersistence()
1132                                       .fetchByU_DT_D_Last(userId, deliveryType, delivered,
1133                            orderByComparator);
1134            }
1135    
1136            /**
1137            * 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;.
1138            *
1139            * @param userNotificationEventId the primary key of the current user notification event
1140            * @param userId the user ID
1141            * @param deliveryType the delivery type
1142            * @param delivered the delivered
1143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1144            * @return the previous, current, and next user notification event
1145            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1146            */
1147            public static UserNotificationEvent[] findByU_DT_D_PrevAndNext(
1148                    long userNotificationEventId, long userId, int deliveryType,
1149                    boolean delivered,
1150                    OrderByComparator<UserNotificationEvent> orderByComparator)
1151                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1152                    return getPersistence()
1153                                       .findByU_DT_D_PrevAndNext(userNotificationEventId, userId,
1154                            deliveryType, delivered, orderByComparator);
1155            }
1156    
1157            /**
1158            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; from the database.
1159            *
1160            * @param userId the user ID
1161            * @param deliveryType the delivery type
1162            * @param delivered the delivered
1163            */
1164            public static void removeByU_DT_D(long userId, int deliveryType,
1165                    boolean delivered) {
1166                    getPersistence().removeByU_DT_D(userId, deliveryType, delivered);
1167            }
1168    
1169            /**
1170            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1171            *
1172            * @param userId the user ID
1173            * @param deliveryType the delivery type
1174            * @param delivered the delivered
1175            * @return the number of matching user notification events
1176            */
1177            public static int countByU_DT_D(long userId, int deliveryType,
1178                    boolean delivered) {
1179                    return getPersistence().countByU_DT_D(userId, deliveryType, delivered);
1180            }
1181    
1182            /**
1183            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1184            *
1185            * @param userId the user ID
1186            * @param deliveryType the delivery type
1187            * @param archived the archived
1188            * @return the matching user notification events
1189            */
1190            public static List<UserNotificationEvent> findByU_DT_A(long userId,
1191                    int deliveryType, boolean archived) {
1192                    return getPersistence().findByU_DT_A(userId, deliveryType, archived);
1193            }
1194    
1195            /**
1196            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1197            *
1198            * <p>
1199            * 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.
1200            * </p>
1201            *
1202            * @param userId the user ID
1203            * @param deliveryType the delivery type
1204            * @param archived the archived
1205            * @param start the lower bound of the range of user notification events
1206            * @param end the upper bound of the range of user notification events (not inclusive)
1207            * @return the range of matching user notification events
1208            */
1209            public static List<UserNotificationEvent> findByU_DT_A(long userId,
1210                    int deliveryType, boolean archived, int start, int end) {
1211                    return getPersistence()
1212                                       .findByU_DT_A(userId, deliveryType, archived, start, end);
1213            }
1214    
1215            /**
1216            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1217            *
1218            * <p>
1219            * 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.
1220            * </p>
1221            *
1222            * @param userId the user ID
1223            * @param deliveryType the delivery type
1224            * @param archived the archived
1225            * @param start the lower bound of the range of user notification events
1226            * @param end the upper bound of the range of user notification events (not inclusive)
1227            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1228            * @return the ordered range of matching user notification events
1229            */
1230            public static List<UserNotificationEvent> findByU_DT_A(long userId,
1231                    int deliveryType, boolean archived, int start, int end,
1232                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1233                    return getPersistence()
1234                                       .findByU_DT_A(userId, deliveryType, archived, start, end,
1235                            orderByComparator);
1236            }
1237    
1238            /**
1239            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1240            *
1241            * @param userId the user ID
1242            * @param deliveryType the delivery type
1243            * @param archived the archived
1244            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1245            * @return the first matching user notification event
1246            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1247            */
1248            public static UserNotificationEvent findByU_DT_A_First(long userId,
1249                    int deliveryType, boolean archived,
1250                    OrderByComparator<UserNotificationEvent> orderByComparator)
1251                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1252                    return getPersistence()
1253                                       .findByU_DT_A_First(userId, deliveryType, archived,
1254                            orderByComparator);
1255            }
1256    
1257            /**
1258            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1259            *
1260            * @param userId the user ID
1261            * @param deliveryType the delivery type
1262            * @param archived the archived
1263            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1264            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1265            */
1266            public static UserNotificationEvent fetchByU_DT_A_First(long userId,
1267                    int deliveryType, boolean archived,
1268                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1269                    return getPersistence()
1270                                       .fetchByU_DT_A_First(userId, deliveryType, archived,
1271                            orderByComparator);
1272            }
1273    
1274            /**
1275            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1276            *
1277            * @param userId the user ID
1278            * @param deliveryType the delivery type
1279            * @param archived the archived
1280            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1281            * @return the last matching user notification event
1282            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1283            */
1284            public static UserNotificationEvent findByU_DT_A_Last(long userId,
1285                    int deliveryType, boolean archived,
1286                    OrderByComparator<UserNotificationEvent> orderByComparator)
1287                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1288                    return getPersistence()
1289                                       .findByU_DT_A_Last(userId, deliveryType, archived,
1290                            orderByComparator);
1291            }
1292    
1293            /**
1294            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1295            *
1296            * @param userId the user ID
1297            * @param deliveryType the delivery type
1298            * @param archived the archived
1299            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1300            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1301            */
1302            public static UserNotificationEvent fetchByU_DT_A_Last(long userId,
1303                    int deliveryType, boolean archived,
1304                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1305                    return getPersistence()
1306                                       .fetchByU_DT_A_Last(userId, deliveryType, archived,
1307                            orderByComparator);
1308            }
1309    
1310            /**
1311            * 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;.
1312            *
1313            * @param userNotificationEventId the primary key of the current user notification event
1314            * @param userId the user ID
1315            * @param deliveryType the delivery type
1316            * @param archived the archived
1317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1318            * @return the previous, current, and next user notification event
1319            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1320            */
1321            public static UserNotificationEvent[] findByU_DT_A_PrevAndNext(
1322                    long userNotificationEventId, long userId, int deliveryType,
1323                    boolean archived,
1324                    OrderByComparator<UserNotificationEvent> orderByComparator)
1325                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1326                    return getPersistence()
1327                                       .findByU_DT_A_PrevAndNext(userNotificationEventId, userId,
1328                            deliveryType, archived, orderByComparator);
1329            }
1330    
1331            /**
1332            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63; from the database.
1333            *
1334            * @param userId the user ID
1335            * @param deliveryType the delivery type
1336            * @param archived the archived
1337            */
1338            public static void removeByU_DT_A(long userId, int deliveryType,
1339                    boolean archived) {
1340                    getPersistence().removeByU_DT_A(userId, deliveryType, archived);
1341            }
1342    
1343            /**
1344            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1345            *
1346            * @param userId the user ID
1347            * @param deliveryType the delivery type
1348            * @param archived the archived
1349            * @return the number of matching user notification events
1350            */
1351            public static int countByU_DT_A(long userId, int deliveryType,
1352                    boolean archived) {
1353                    return getPersistence().countByU_DT_A(userId, deliveryType, archived);
1354            }
1355    
1356            /**
1357            * Returns all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1358            *
1359            * @param userId the user ID
1360            * @param delivered the delivered
1361            * @param actionRequired the action required
1362            * @return the matching user notification events
1363            */
1364            public static List<UserNotificationEvent> findByU_D_A(long userId,
1365                    boolean delivered, boolean actionRequired) {
1366                    return getPersistence().findByU_D_A(userId, delivered, actionRequired);
1367            }
1368    
1369            /**
1370            * Returns a range of all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1371            *
1372            * <p>
1373            * 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.
1374            * </p>
1375            *
1376            * @param userId the user ID
1377            * @param delivered the delivered
1378            * @param actionRequired the action required
1379            * @param start the lower bound of the range of user notification events
1380            * @param end the upper bound of the range of user notification events (not inclusive)
1381            * @return the range of matching user notification events
1382            */
1383            public static List<UserNotificationEvent> findByU_D_A(long userId,
1384                    boolean delivered, boolean actionRequired, int start, int end) {
1385                    return getPersistence()
1386                                       .findByU_D_A(userId, delivered, actionRequired, start, end);
1387            }
1388    
1389            /**
1390            * Returns an ordered range of all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1391            *
1392            * <p>
1393            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1394            * </p>
1395            *
1396            * @param userId the user ID
1397            * @param delivered the delivered
1398            * @param actionRequired the action required
1399            * @param start the lower bound of the range of user notification events
1400            * @param end the upper bound of the range of user notification events (not inclusive)
1401            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1402            * @return the ordered range of matching user notification events
1403            */
1404            public static List<UserNotificationEvent> findByU_D_A(long userId,
1405                    boolean delivered, boolean actionRequired, int start, int end,
1406                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1407                    return getPersistence()
1408                                       .findByU_D_A(userId, delivered, actionRequired, start, end,
1409                            orderByComparator);
1410            }
1411    
1412            /**
1413            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1414            *
1415            * @param userId the user ID
1416            * @param delivered the delivered
1417            * @param actionRequired the action required
1418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1419            * @return the first matching user notification event
1420            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1421            */
1422            public static UserNotificationEvent findByU_D_A_First(long userId,
1423                    boolean delivered, boolean actionRequired,
1424                    OrderByComparator<UserNotificationEvent> orderByComparator)
1425                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1426                    return getPersistence()
1427                                       .findByU_D_A_First(userId, delivered, actionRequired,
1428                            orderByComparator);
1429            }
1430    
1431            /**
1432            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1433            *
1434            * @param userId the user ID
1435            * @param delivered the delivered
1436            * @param actionRequired the action required
1437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1438            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1439            */
1440            public static UserNotificationEvent fetchByU_D_A_First(long userId,
1441                    boolean delivered, boolean actionRequired,
1442                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1443                    return getPersistence()
1444                                       .fetchByU_D_A_First(userId, delivered, actionRequired,
1445                            orderByComparator);
1446            }
1447    
1448            /**
1449            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1450            *
1451            * @param userId the user ID
1452            * @param delivered the delivered
1453            * @param actionRequired the action required
1454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1455            * @return the last matching user notification event
1456            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1457            */
1458            public static UserNotificationEvent findByU_D_A_Last(long userId,
1459                    boolean delivered, boolean actionRequired,
1460                    OrderByComparator<UserNotificationEvent> orderByComparator)
1461                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1462                    return getPersistence()
1463                                       .findByU_D_A_Last(userId, delivered, actionRequired,
1464                            orderByComparator);
1465            }
1466    
1467            /**
1468            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1469            *
1470            * @param userId the user ID
1471            * @param delivered the delivered
1472            * @param actionRequired the action required
1473            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1474            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1475            */
1476            public static UserNotificationEvent fetchByU_D_A_Last(long userId,
1477                    boolean delivered, boolean actionRequired,
1478                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1479                    return getPersistence()
1480                                       .fetchByU_D_A_Last(userId, delivered, actionRequired,
1481                            orderByComparator);
1482            }
1483    
1484            /**
1485            * 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;.
1486            *
1487            * @param userNotificationEventId the primary key of the current user notification event
1488            * @param userId the user ID
1489            * @param delivered the delivered
1490            * @param actionRequired the action required
1491            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1492            * @return the previous, current, and next user notification event
1493            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1494            */
1495            public static UserNotificationEvent[] findByU_D_A_PrevAndNext(
1496                    long userNotificationEventId, long userId, boolean delivered,
1497                    boolean actionRequired,
1498                    OrderByComparator<UserNotificationEvent> orderByComparator)
1499                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1500                    return getPersistence()
1501                                       .findByU_D_A_PrevAndNext(userNotificationEventId, userId,
1502                            delivered, actionRequired, orderByComparator);
1503            }
1504    
1505            /**
1506            * Removes all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63; from the database.
1507            *
1508            * @param userId the user ID
1509            * @param delivered the delivered
1510            * @param actionRequired the action required
1511            */
1512            public static void removeByU_D_A(long userId, boolean delivered,
1513                    boolean actionRequired) {
1514                    getPersistence().removeByU_D_A(userId, delivered, actionRequired);
1515            }
1516    
1517            /**
1518            * Returns the number of user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1519            *
1520            * @param userId the user ID
1521            * @param delivered the delivered
1522            * @param actionRequired the action required
1523            * @return the number of matching user notification events
1524            */
1525            public static int countByU_D_A(long userId, boolean delivered,
1526                    boolean actionRequired) {
1527                    return getPersistence().countByU_D_A(userId, delivered, actionRequired);
1528            }
1529    
1530            /**
1531            * Returns all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1532            *
1533            * @param userId the user ID
1534            * @param actionRequired the action required
1535            * @param archived the archived
1536            * @return the matching user notification events
1537            */
1538            public static List<UserNotificationEvent> findByU_A_A(long userId,
1539                    boolean actionRequired, boolean archived) {
1540                    return getPersistence().findByU_A_A(userId, actionRequired, archived);
1541            }
1542    
1543            /**
1544            * Returns a range of all the user notification events where userId = &#63; and actionRequired = &#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 actionRequired the action required
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            * @return the range of matching user notification events
1556            */
1557            public static List<UserNotificationEvent> findByU_A_A(long userId,
1558                    boolean actionRequired, boolean archived, int start, int end) {
1559                    return getPersistence()
1560                                       .findByU_A_A(userId, actionRequired, archived, start, end);
1561            }
1562    
1563            /**
1564            * Returns an ordered range of all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1565            *
1566            * <p>
1567            * 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.
1568            * </p>
1569            *
1570            * @param userId the user ID
1571            * @param actionRequired the action required
1572            * @param archived the archived
1573            * @param start the lower bound of the range of user notification events
1574            * @param end the upper bound of the range of user notification events (not inclusive)
1575            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1576            * @return the ordered range of matching user notification events
1577            */
1578            public static List<UserNotificationEvent> findByU_A_A(long userId,
1579                    boolean actionRequired, boolean archived, int start, int end,
1580                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1581                    return getPersistence()
1582                                       .findByU_A_A(userId, actionRequired, archived, start, end,
1583                            orderByComparator);
1584            }
1585    
1586            /**
1587            * Returns the first user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1588            *
1589            * @param userId the user ID
1590            * @param actionRequired the action required
1591            * @param archived the archived
1592            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1593            * @return the first matching user notification event
1594            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1595            */
1596            public static UserNotificationEvent findByU_A_A_First(long userId,
1597                    boolean actionRequired, boolean archived,
1598                    OrderByComparator<UserNotificationEvent> orderByComparator)
1599                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1600                    return getPersistence()
1601                                       .findByU_A_A_First(userId, actionRequired, archived,
1602                            orderByComparator);
1603            }
1604    
1605            /**
1606            * Returns the first user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1607            *
1608            * @param userId the user ID
1609            * @param actionRequired the action required
1610            * @param archived the archived
1611            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1612            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1613            */
1614            public static UserNotificationEvent fetchByU_A_A_First(long userId,
1615                    boolean actionRequired, boolean archived,
1616                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1617                    return getPersistence()
1618                                       .fetchByU_A_A_First(userId, actionRequired, archived,
1619                            orderByComparator);
1620            }
1621    
1622            /**
1623            * Returns the last user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1624            *
1625            * @param userId the user ID
1626            * @param actionRequired the action required
1627            * @param archived the archived
1628            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1629            * @return the last matching user notification event
1630            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1631            */
1632            public static UserNotificationEvent findByU_A_A_Last(long userId,
1633                    boolean actionRequired, boolean archived,
1634                    OrderByComparator<UserNotificationEvent> orderByComparator)
1635                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1636                    return getPersistence()
1637                                       .findByU_A_A_Last(userId, actionRequired, archived,
1638                            orderByComparator);
1639            }
1640    
1641            /**
1642            * Returns the last user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1643            *
1644            * @param userId the user ID
1645            * @param actionRequired the action required
1646            * @param archived the archived
1647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1648            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1649            */
1650            public static UserNotificationEvent fetchByU_A_A_Last(long userId,
1651                    boolean actionRequired, boolean archived,
1652                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1653                    return getPersistence()
1654                                       .fetchByU_A_A_Last(userId, actionRequired, archived,
1655                            orderByComparator);
1656            }
1657    
1658            /**
1659            * 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;.
1660            *
1661            * @param userNotificationEventId the primary key of the current user notification event
1662            * @param userId the user ID
1663            * @param actionRequired the action required
1664            * @param archived the archived
1665            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1666            * @return the previous, current, and next user notification event
1667            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1668            */
1669            public static UserNotificationEvent[] findByU_A_A_PrevAndNext(
1670                    long userNotificationEventId, long userId, boolean actionRequired,
1671                    boolean archived,
1672                    OrderByComparator<UserNotificationEvent> orderByComparator)
1673                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1674                    return getPersistence()
1675                                       .findByU_A_A_PrevAndNext(userNotificationEventId, userId,
1676                            actionRequired, archived, orderByComparator);
1677            }
1678    
1679            /**
1680            * Removes all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63; from the database.
1681            *
1682            * @param userId the user ID
1683            * @param actionRequired the action required
1684            * @param archived the archived
1685            */
1686            public static void removeByU_A_A(long userId, boolean actionRequired,
1687                    boolean archived) {
1688                    getPersistence().removeByU_A_A(userId, actionRequired, archived);
1689            }
1690    
1691            /**
1692            * Returns the number of user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1693            *
1694            * @param userId the user ID
1695            * @param actionRequired the action required
1696            * @param archived the archived
1697            * @return the number of matching user notification events
1698            */
1699            public static int countByU_A_A(long userId, boolean actionRequired,
1700                    boolean archived) {
1701                    return getPersistence().countByU_A_A(userId, actionRequired, archived);
1702            }
1703    
1704            /**
1705            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1706            *
1707            * @param userId the user ID
1708            * @param deliveryType the delivery type
1709            * @param delivered the delivered
1710            * @param actionRequired the action required
1711            * @return the matching user notification events
1712            */
1713            public static List<UserNotificationEvent> findByU_DT_D_A(long userId,
1714                    int deliveryType, boolean delivered, boolean actionRequired) {
1715                    return getPersistence()
1716                                       .findByU_DT_D_A(userId, deliveryType, delivered,
1717                            actionRequired);
1718            }
1719    
1720            /**
1721            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1722            *
1723            * <p>
1724            * 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.
1725            * </p>
1726            *
1727            * @param userId the user ID
1728            * @param deliveryType the delivery type
1729            * @param delivered the delivered
1730            * @param actionRequired the action required
1731            * @param start the lower bound of the range of user notification events
1732            * @param end the upper bound of the range of user notification events (not inclusive)
1733            * @return the range of matching user notification events
1734            */
1735            public static List<UserNotificationEvent> findByU_DT_D_A(long userId,
1736                    int deliveryType, boolean delivered, boolean actionRequired, int start,
1737                    int end) {
1738                    return getPersistence()
1739                                       .findByU_DT_D_A(userId, deliveryType, delivered,
1740                            actionRequired, start, end);
1741            }
1742    
1743            /**
1744            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1745            *
1746            * <p>
1747            * 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.
1748            * </p>
1749            *
1750            * @param userId the user ID
1751            * @param deliveryType the delivery type
1752            * @param delivered the delivered
1753            * @param actionRequired the action required
1754            * @param start the lower bound of the range of user notification events
1755            * @param end the upper bound of the range of user notification events (not inclusive)
1756            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1757            * @return the ordered range of matching user notification events
1758            */
1759            public static List<UserNotificationEvent> findByU_DT_D_A(long userId,
1760                    int deliveryType, boolean delivered, boolean actionRequired, int start,
1761                    int end, OrderByComparator<UserNotificationEvent> orderByComparator) {
1762                    return getPersistence()
1763                                       .findByU_DT_D_A(userId, deliveryType, delivered,
1764                            actionRequired, start, end, orderByComparator);
1765            }
1766    
1767            /**
1768            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1769            *
1770            * @param userId the user ID
1771            * @param deliveryType the delivery type
1772            * @param delivered the delivered
1773            * @param actionRequired the action required
1774            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1775            * @return the first matching user notification event
1776            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1777            */
1778            public static UserNotificationEvent findByU_DT_D_A_First(long userId,
1779                    int deliveryType, boolean delivered, boolean actionRequired,
1780                    OrderByComparator<UserNotificationEvent> orderByComparator)
1781                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1782                    return getPersistence()
1783                                       .findByU_DT_D_A_First(userId, deliveryType, delivered,
1784                            actionRequired, orderByComparator);
1785            }
1786    
1787            /**
1788            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1789            *
1790            * @param userId the user ID
1791            * @param deliveryType the delivery type
1792            * @param delivered the delivered
1793            * @param actionRequired the action required
1794            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1795            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1796            */
1797            public static UserNotificationEvent fetchByU_DT_D_A_First(long userId,
1798                    int deliveryType, boolean delivered, boolean actionRequired,
1799                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1800                    return getPersistence()
1801                                       .fetchByU_DT_D_A_First(userId, deliveryType, delivered,
1802                            actionRequired, orderByComparator);
1803            }
1804    
1805            /**
1806            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1807            *
1808            * @param userId the user ID
1809            * @param deliveryType the delivery type
1810            * @param delivered the delivered
1811            * @param actionRequired the action required
1812            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1813            * @return the last matching user notification event
1814            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1815            */
1816            public static UserNotificationEvent findByU_DT_D_A_Last(long userId,
1817                    int deliveryType, boolean delivered, boolean actionRequired,
1818                    OrderByComparator<UserNotificationEvent> orderByComparator)
1819                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1820                    return getPersistence()
1821                                       .findByU_DT_D_A_Last(userId, deliveryType, delivered,
1822                            actionRequired, orderByComparator);
1823            }
1824    
1825            /**
1826            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1827            *
1828            * @param userId the user ID
1829            * @param deliveryType the delivery type
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, or <code>null</code> if a matching user notification event could not be found
1834            */
1835            public static UserNotificationEvent fetchByU_DT_D_A_Last(long userId,
1836                    int deliveryType, boolean delivered, boolean actionRequired,
1837                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1838                    return getPersistence()
1839                                       .fetchByU_DT_D_A_Last(userId, deliveryType, delivered,
1840                            actionRequired, orderByComparator);
1841            }
1842    
1843            /**
1844            * 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;.
1845            *
1846            * @param userNotificationEventId the primary key of the current user notification event
1847            * @param userId the user ID
1848            * @param deliveryType the delivery type
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 previous, current, and next user notification event
1853            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1854            */
1855            public static UserNotificationEvent[] findByU_DT_D_A_PrevAndNext(
1856                    long userNotificationEventId, long userId, int deliveryType,
1857                    boolean delivered, boolean actionRequired,
1858                    OrderByComparator<UserNotificationEvent> orderByComparator)
1859                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1860                    return getPersistence()
1861                                       .findByU_DT_D_A_PrevAndNext(userNotificationEventId, userId,
1862                            deliveryType, delivered, actionRequired, orderByComparator);
1863            }
1864    
1865            /**
1866            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63; from the database.
1867            *
1868            * @param userId the user ID
1869            * @param deliveryType the delivery type
1870            * @param delivered the delivered
1871            * @param actionRequired the action required
1872            */
1873            public static void removeByU_DT_D_A(long userId, int deliveryType,
1874                    boolean delivered, boolean actionRequired) {
1875                    getPersistence()
1876                            .removeByU_DT_D_A(userId, deliveryType, delivered, actionRequired);
1877            }
1878    
1879            /**
1880            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1881            *
1882            * @param userId the user ID
1883            * @param deliveryType the delivery type
1884            * @param delivered the delivered
1885            * @param actionRequired the action required
1886            * @return the number of matching user notification events
1887            */
1888            public static int countByU_DT_D_A(long userId, int deliveryType,
1889                    boolean delivered, boolean actionRequired) {
1890                    return getPersistence()
1891                                       .countByU_DT_D_A(userId, deliveryType, delivered,
1892                            actionRequired);
1893            }
1894    
1895            /**
1896            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1897            *
1898            * @param userId the user ID
1899            * @param deliveryType the delivery type
1900            * @param actionRequired the action required
1901            * @param archived the archived
1902            * @return the matching user notification events
1903            */
1904            public static List<UserNotificationEvent> findByU_DT_A_A(long userId,
1905                    int deliveryType, boolean actionRequired, boolean archived) {
1906                    return getPersistence()
1907                                       .findByU_DT_A_A(userId, deliveryType, actionRequired,
1908                            archived);
1909            }
1910    
1911            /**
1912            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1913            *
1914            * <p>
1915            * 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.
1916            * </p>
1917            *
1918            * @param userId the user ID
1919            * @param deliveryType the delivery type
1920            * @param actionRequired the action required
1921            * @param archived the archived
1922            * @param start the lower bound of the range of user notification events
1923            * @param end the upper bound of the range of user notification events (not inclusive)
1924            * @return the range of matching user notification events
1925            */
1926            public static List<UserNotificationEvent> findByU_DT_A_A(long userId,
1927                    int deliveryType, boolean actionRequired, boolean archived, int start,
1928                    int end) {
1929                    return getPersistence()
1930                                       .findByU_DT_A_A(userId, deliveryType, actionRequired,
1931                            archived, start, end);
1932            }
1933    
1934            /**
1935            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1936            *
1937            * <p>
1938            * 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.
1939            * </p>
1940            *
1941            * @param userId the user ID
1942            * @param deliveryType the delivery type
1943            * @param actionRequired the action required
1944            * @param archived the archived
1945            * @param start the lower bound of the range of user notification events
1946            * @param end the upper bound of the range of user notification events (not inclusive)
1947            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1948            * @return the ordered range of matching user notification events
1949            */
1950            public static List<UserNotificationEvent> findByU_DT_A_A(long userId,
1951                    int deliveryType, boolean actionRequired, boolean archived, int start,
1952                    int end, OrderByComparator<UserNotificationEvent> orderByComparator) {
1953                    return getPersistence()
1954                                       .findByU_DT_A_A(userId, deliveryType, actionRequired,
1955                            archived, start, end, orderByComparator);
1956            }
1957    
1958            /**
1959            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1960            *
1961            * @param userId the user ID
1962            * @param deliveryType the delivery type
1963            * @param actionRequired the action required
1964            * @param archived the archived
1965            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1966            * @return the first matching user notification event
1967            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1968            */
1969            public static UserNotificationEvent findByU_DT_A_A_First(long userId,
1970                    int deliveryType, boolean actionRequired, boolean archived,
1971                    OrderByComparator<UserNotificationEvent> orderByComparator)
1972                    throws com.liferay.portal.NoSuchUserNotificationEventException {
1973                    return getPersistence()
1974                                       .findByU_DT_A_A_First(userId, deliveryType, actionRequired,
1975                            archived, orderByComparator);
1976            }
1977    
1978            /**
1979            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1980            *
1981            * @param userId the user ID
1982            * @param deliveryType the delivery type
1983            * @param actionRequired the action required
1984            * @param archived the archived
1985            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1986            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1987            */
1988            public static UserNotificationEvent fetchByU_DT_A_A_First(long userId,
1989                    int deliveryType, boolean actionRequired, boolean archived,
1990                    OrderByComparator<UserNotificationEvent> orderByComparator) {
1991                    return getPersistence()
1992                                       .fetchByU_DT_A_A_First(userId, deliveryType, actionRequired,
1993                            archived, orderByComparator);
1994            }
1995    
1996            /**
1997            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1998            *
1999            * @param userId the user ID
2000            * @param deliveryType the delivery type
2001            * @param actionRequired the action required
2002            * @param archived the archived
2003            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2004            * @return the last matching user notification event
2005            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
2006            */
2007            public static UserNotificationEvent findByU_DT_A_A_Last(long userId,
2008                    int deliveryType, boolean actionRequired, boolean archived,
2009                    OrderByComparator<UserNotificationEvent> orderByComparator)
2010                    throws com.liferay.portal.NoSuchUserNotificationEventException {
2011                    return getPersistence()
2012                                       .findByU_DT_A_A_Last(userId, deliveryType, actionRequired,
2013                            archived, orderByComparator);
2014            }
2015    
2016            /**
2017            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
2018            *
2019            * @param userId the user ID
2020            * @param deliveryType the delivery type
2021            * @param actionRequired the action required
2022            * @param archived the archived
2023            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2024            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
2025            */
2026            public static UserNotificationEvent fetchByU_DT_A_A_Last(long userId,
2027                    int deliveryType, boolean actionRequired, boolean archived,
2028                    OrderByComparator<UserNotificationEvent> orderByComparator) {
2029                    return getPersistence()
2030                                       .fetchByU_DT_A_A_Last(userId, deliveryType, actionRequired,
2031                            archived, orderByComparator);
2032            }
2033    
2034            /**
2035            * 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;.
2036            *
2037            * @param userNotificationEventId the primary key of the current user notification event
2038            * @param userId the user ID
2039            * @param deliveryType the delivery type
2040            * @param actionRequired the action required
2041            * @param archived the archived
2042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2043            * @return the previous, current, and next user notification event
2044            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
2045            */
2046            public static UserNotificationEvent[] findByU_DT_A_A_PrevAndNext(
2047                    long userNotificationEventId, long userId, int deliveryType,
2048                    boolean actionRequired, boolean archived,
2049                    OrderByComparator<UserNotificationEvent> orderByComparator)
2050                    throws com.liferay.portal.NoSuchUserNotificationEventException {
2051                    return getPersistence()
2052                                       .findByU_DT_A_A_PrevAndNext(userNotificationEventId, userId,
2053                            deliveryType, actionRequired, archived, orderByComparator);
2054            }
2055    
2056            /**
2057            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63; from the database.
2058            *
2059            * @param userId the user ID
2060            * @param deliveryType the delivery type
2061            * @param actionRequired the action required
2062            * @param archived the archived
2063            */
2064            public static void removeByU_DT_A_A(long userId, int deliveryType,
2065                    boolean actionRequired, boolean archived) {
2066                    getPersistence()
2067                            .removeByU_DT_A_A(userId, deliveryType, actionRequired, archived);
2068            }
2069    
2070            /**
2071            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
2072            *
2073            * @param userId the user ID
2074            * @param deliveryType the delivery type
2075            * @param actionRequired the action required
2076            * @param archived the archived
2077            * @return the number of matching user notification events
2078            */
2079            public static int countByU_DT_A_A(long userId, int deliveryType,
2080                    boolean actionRequired, boolean archived) {
2081                    return getPersistence()
2082                                       .countByU_DT_A_A(userId, deliveryType, actionRequired,
2083                            archived);
2084            }
2085    
2086            /**
2087            * Caches the user notification event in the entity cache if it is enabled.
2088            *
2089            * @param userNotificationEvent the user notification event
2090            */
2091            public static void cacheResult(UserNotificationEvent userNotificationEvent) {
2092                    getPersistence().cacheResult(userNotificationEvent);
2093            }
2094    
2095            /**
2096            * Caches the user notification events in the entity cache if it is enabled.
2097            *
2098            * @param userNotificationEvents the user notification events
2099            */
2100            public static void cacheResult(
2101                    List<UserNotificationEvent> userNotificationEvents) {
2102                    getPersistence().cacheResult(userNotificationEvents);
2103            }
2104    
2105            /**
2106            * Creates a new user notification event with the primary key. Does not add the user notification event to the database.
2107            *
2108            * @param userNotificationEventId the primary key for the new user notification event
2109            * @return the new user notification event
2110            */
2111            public static UserNotificationEvent create(long userNotificationEventId) {
2112                    return getPersistence().create(userNotificationEventId);
2113            }
2114    
2115            /**
2116            * Removes the user notification event with the primary key from the database. Also notifies the appropriate model listeners.
2117            *
2118            * @param userNotificationEventId the primary key of the user notification event
2119            * @return the user notification event that was removed
2120            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
2121            */
2122            public static UserNotificationEvent remove(long userNotificationEventId)
2123                    throws com.liferay.portal.NoSuchUserNotificationEventException {
2124                    return getPersistence().remove(userNotificationEventId);
2125            }
2126    
2127            public static UserNotificationEvent updateImpl(
2128                    UserNotificationEvent userNotificationEvent) {
2129                    return getPersistence().updateImpl(userNotificationEvent);
2130            }
2131    
2132            /**
2133            * Returns the user notification event with the primary key or throws a {@link NoSuchUserNotificationEventException} if it could not be found.
2134            *
2135            * @param userNotificationEventId the primary key of the user notification event
2136            * @return the user notification event
2137            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
2138            */
2139            public static UserNotificationEvent findByPrimaryKey(
2140                    long userNotificationEventId)
2141                    throws com.liferay.portal.NoSuchUserNotificationEventException {
2142                    return getPersistence().findByPrimaryKey(userNotificationEventId);
2143            }
2144    
2145            /**
2146            * Returns the user notification event with the primary key or returns <code>null</code> if it could not be found.
2147            *
2148            * @param userNotificationEventId the primary key of the user notification event
2149            * @return the user notification event, or <code>null</code> if a user notification event with the primary key could not be found
2150            */
2151            public static UserNotificationEvent fetchByPrimaryKey(
2152                    long userNotificationEventId) {
2153                    return getPersistence().fetchByPrimaryKey(userNotificationEventId);
2154            }
2155    
2156            public static java.util.Map<java.io.Serializable, UserNotificationEvent> fetchByPrimaryKeys(
2157                    java.util.Set<java.io.Serializable> primaryKeys) {
2158                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2159            }
2160    
2161            /**
2162            * Returns all the user notification events.
2163            *
2164            * @return the user notification events
2165            */
2166            public static List<UserNotificationEvent> findAll() {
2167                    return getPersistence().findAll();
2168            }
2169    
2170            /**
2171            * Returns a range of all the user notification events.
2172            *
2173            * <p>
2174            * 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.
2175            * </p>
2176            *
2177            * @param start the lower bound of the range of user notification events
2178            * @param end the upper bound of the range of user notification events (not inclusive)
2179            * @return the range of user notification events
2180            */
2181            public static List<UserNotificationEvent> findAll(int start, int end) {
2182                    return getPersistence().findAll(start, end);
2183            }
2184    
2185            /**
2186            * Returns an ordered range of all the user notification events.
2187            *
2188            * <p>
2189            * 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.
2190            * </p>
2191            *
2192            * @param start the lower bound of the range of user notification events
2193            * @param end the upper bound of the range of user notification events (not inclusive)
2194            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2195            * @return the ordered range of user notification events
2196            */
2197            public static List<UserNotificationEvent> findAll(int start, int end,
2198                    OrderByComparator<UserNotificationEvent> orderByComparator) {
2199                    return getPersistence().findAll(start, end, orderByComparator);
2200            }
2201    
2202            /**
2203            * Removes all the user notification events from the database.
2204            */
2205            public static void removeAll() {
2206                    getPersistence().removeAll();
2207            }
2208    
2209            /**
2210            * Returns the number of user notification events.
2211            *
2212            * @return the number of user notification events
2213            */
2214            public static int countAll() {
2215                    return getPersistence().countAll();
2216            }
2217    
2218            public static UserNotificationEventPersistence getPersistence() {
2219                    if (_persistence == null) {
2220                            _persistence = (UserNotificationEventPersistence)PortalBeanLocatorUtil.locate(UserNotificationEventPersistence.class.getName());
2221    
2222                            ReferenceRegistry.registerReference(UserNotificationEventUtil.class,
2223                                    "_persistence");
2224                    }
2225    
2226                    return _persistence;
2227            }
2228    
2229            /**
2230             * @deprecated As of 6.2.0
2231             */
2232            @Deprecated
2233            public void setPersistence(UserNotificationEventPersistence persistence) {
2234            }
2235    
2236            private static UserNotificationEventPersistence _persistence;
2237    }