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