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