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