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.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.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.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.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.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.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.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.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.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 userId = &#63; and deliveryType = &#63;.
456            *
457            * @param userId the user ID
458            * @param deliveryType the delivery type
459            * @return the matching user notification events
460            */
461            public java.util.List<UserNotificationEvent> findByU_DT(long userId,
462                    int deliveryType);
463    
464            /**
465            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63;.
466            *
467            * <p>
468            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
469            * </p>
470            *
471            * @param userId the user ID
472            * @param deliveryType the delivery type
473            * @param start the lower bound of the range of user notification events
474            * @param end the upper bound of the range of user notification events (not inclusive)
475            * @return the range of matching user notification events
476            */
477            public java.util.List<UserNotificationEvent> findByU_DT(long userId,
478                    int deliveryType, int start, int end);
479    
480            /**
481            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63;.
482            *
483            * <p>
484            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
485            * </p>
486            *
487            * @param userId the user ID
488            * @param deliveryType the delivery type
489            * @param start the lower bound of the range of user notification events
490            * @param end the upper bound of the range of user notification events (not inclusive)
491            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
492            * @return the ordered range of matching user notification events
493            */
494            public java.util.List<UserNotificationEvent> findByU_DT(long userId,
495                    int deliveryType, int start, int end,
496                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
497    
498            /**
499            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63;.
500            *
501            * <p>
502            * 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.
503            * </p>
504            *
505            * @param userId the user ID
506            * @param deliveryType the delivery type
507            * @param start the lower bound of the range of user notification events
508            * @param end the upper bound of the range of user notification events (not inclusive)
509            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
510            * @param retrieveFromCache whether to retrieve from the finder cache
511            * @return the ordered range of matching user notification events
512            */
513            public java.util.List<UserNotificationEvent> findByU_DT(long userId,
514                    int deliveryType, int start, int end,
515                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
516                    boolean retrieveFromCache);
517    
518            /**
519            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
520            *
521            * @param userId the user ID
522            * @param deliveryType the delivery type
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the first matching user notification event
525            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
526            */
527            public UserNotificationEvent findByU_DT_First(long userId,
528                    int deliveryType,
529                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
530                    throws com.liferay.portal.NoSuchUserNotificationEventException;
531    
532            /**
533            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
534            *
535            * @param userId the user ID
536            * @param deliveryType the delivery type
537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
538            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
539            */
540            public UserNotificationEvent fetchByU_DT_First(long userId,
541                    int deliveryType,
542                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
543    
544            /**
545            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
546            *
547            * @param userId the user ID
548            * @param deliveryType the delivery type
549            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
550            * @return the last matching user notification event
551            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
552            */
553            public UserNotificationEvent findByU_DT_Last(long userId, int deliveryType,
554                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
555                    throws com.liferay.portal.NoSuchUserNotificationEventException;
556    
557            /**
558            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
559            *
560            * @param userId the user ID
561            * @param deliveryType the delivery type
562            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
563            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
564            */
565            public UserNotificationEvent fetchByU_DT_Last(long userId,
566                    int deliveryType,
567                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
568    
569            /**
570            * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and deliveryType = &#63;.
571            *
572            * @param userNotificationEventId the primary key of the current user notification event
573            * @param userId the user ID
574            * @param deliveryType the delivery type
575            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
576            * @return the previous, current, and next user notification event
577            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
578            */
579            public UserNotificationEvent[] findByU_DT_PrevAndNext(
580                    long userNotificationEventId, long userId, int deliveryType,
581                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
582                    throws com.liferay.portal.NoSuchUserNotificationEventException;
583    
584            /**
585            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; from the database.
586            *
587            * @param userId the user ID
588            * @param deliveryType the delivery type
589            */
590            public void removeByU_DT(long userId, int deliveryType);
591    
592            /**
593            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63;.
594            *
595            * @param userId the user ID
596            * @param deliveryType the delivery type
597            * @return the number of matching user notification events
598            */
599            public int countByU_DT(long userId, int deliveryType);
600    
601            /**
602            * Returns all the user notification events where userId = &#63; and delivered = &#63;.
603            *
604            * @param userId the user ID
605            * @param delivered the delivered
606            * @return the matching user notification events
607            */
608            public java.util.List<UserNotificationEvent> findByU_D(long userId,
609                    boolean delivered);
610    
611            /**
612            * Returns a range of all the user notification events where userId = &#63; and delivered = &#63;.
613            *
614            * <p>
615            * 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.
616            * </p>
617            *
618            * @param userId the user ID
619            * @param delivered the delivered
620            * @param start the lower bound of the range of user notification events
621            * @param end the upper bound of the range of user notification events (not inclusive)
622            * @return the range of matching user notification events
623            */
624            public java.util.List<UserNotificationEvent> findByU_D(long userId,
625                    boolean delivered, int start, int end);
626    
627            /**
628            * Returns an ordered range of all the user notification events where userId = &#63; and delivered = &#63;.
629            *
630            * <p>
631            * 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.
632            * </p>
633            *
634            * @param userId the user ID
635            * @param delivered the delivered
636            * @param start the lower bound of the range of user notification events
637            * @param end the upper bound of the range of user notification events (not inclusive)
638            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
639            * @return the ordered range of matching user notification events
640            */
641            public java.util.List<UserNotificationEvent> findByU_D(long userId,
642                    boolean delivered, int start, int end,
643                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
644    
645            /**
646            * Returns an ordered range of all the user notification events where userId = &#63; and delivered = &#63;.
647            *
648            * <p>
649            * 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.
650            * </p>
651            *
652            * @param userId the user ID
653            * @param delivered the delivered
654            * @param start the lower bound of the range of user notification events
655            * @param end the upper bound of the range of user notification events (not inclusive)
656            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
657            * @param retrieveFromCache whether to retrieve from the finder cache
658            * @return the ordered range of matching user notification events
659            */
660            public java.util.List<UserNotificationEvent> findByU_D(long userId,
661                    boolean delivered, int start, int end,
662                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
663                    boolean retrieveFromCache);
664    
665            /**
666            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63;.
667            *
668            * @param userId the user ID
669            * @param delivered the delivered
670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
671            * @return the first matching user notification event
672            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
673            */
674            public UserNotificationEvent findByU_D_First(long userId,
675                    boolean delivered,
676                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
677                    throws com.liferay.portal.NoSuchUserNotificationEventException;
678    
679            /**
680            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63;.
681            *
682            * @param userId the user ID
683            * @param delivered the delivered
684            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
685            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
686            */
687            public UserNotificationEvent fetchByU_D_First(long userId,
688                    boolean delivered,
689                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
690    
691            /**
692            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63;.
693            *
694            * @param userId the user ID
695            * @param delivered the delivered
696            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
697            * @return the last matching user notification event
698            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
699            */
700            public UserNotificationEvent findByU_D_Last(long userId, boolean delivered,
701                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
702                    throws com.liferay.portal.NoSuchUserNotificationEventException;
703    
704            /**
705            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63;.
706            *
707            * @param userId the user ID
708            * @param delivered the delivered
709            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
710            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
711            */
712            public UserNotificationEvent fetchByU_D_Last(long userId,
713                    boolean delivered,
714                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
715    
716            /**
717            * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and delivered = &#63;.
718            *
719            * @param userNotificationEventId the primary key of the current user notification event
720            * @param userId the user ID
721            * @param delivered the delivered
722            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
723            * @return the previous, current, and next user notification event
724            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
725            */
726            public UserNotificationEvent[] findByU_D_PrevAndNext(
727                    long userNotificationEventId, long userId, boolean delivered,
728                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
729                    throws com.liferay.portal.NoSuchUserNotificationEventException;
730    
731            /**
732            * Removes all the user notification events where userId = &#63; and delivered = &#63; from the database.
733            *
734            * @param userId the user ID
735            * @param delivered the delivered
736            */
737            public void removeByU_D(long userId, boolean delivered);
738    
739            /**
740            * Returns the number of user notification events where userId = &#63; and delivered = &#63;.
741            *
742            * @param userId the user ID
743            * @param delivered the delivered
744            * @return the number of matching user notification events
745            */
746            public int countByU_D(long userId, boolean delivered);
747    
748            /**
749            * Returns all the user notification events where userId = &#63; and archived = &#63;.
750            *
751            * @param userId the user ID
752            * @param archived the archived
753            * @return the matching user notification events
754            */
755            public java.util.List<UserNotificationEvent> findByU_A(long userId,
756                    boolean archived);
757    
758            /**
759            * Returns a range of all the user notification events where userId = &#63; and archived = &#63;.
760            *
761            * <p>
762            * 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.
763            * </p>
764            *
765            * @param userId the user ID
766            * @param archived the archived
767            * @param start the lower bound of the range of user notification events
768            * @param end the upper bound of the range of user notification events (not inclusive)
769            * @return the range of matching user notification events
770            */
771            public java.util.List<UserNotificationEvent> findByU_A(long userId,
772                    boolean archived, int start, int end);
773    
774            /**
775            * Returns an ordered range of all the user notification events where userId = &#63; and archived = &#63;.
776            *
777            * <p>
778            * 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.
779            * </p>
780            *
781            * @param userId the user ID
782            * @param archived the archived
783            * @param start the lower bound of the range of user notification events
784            * @param end the upper bound of the range of user notification events (not inclusive)
785            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
786            * @return the ordered range of matching user notification events
787            */
788            public java.util.List<UserNotificationEvent> findByU_A(long userId,
789                    boolean archived, int start, int end,
790                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
791    
792            /**
793            * Returns an ordered range of all the user notification events where userId = &#63; and archived = &#63;.
794            *
795            * <p>
796            * 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.
797            * </p>
798            *
799            * @param userId the user ID
800            * @param archived the archived
801            * @param start the lower bound of the range of user notification events
802            * @param end the upper bound of the range of user notification events (not inclusive)
803            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
804            * @param retrieveFromCache whether to retrieve from the finder cache
805            * @return the ordered range of matching user notification events
806            */
807            public java.util.List<UserNotificationEvent> findByU_A(long userId,
808                    boolean archived, int start, int end,
809                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
810                    boolean retrieveFromCache);
811    
812            /**
813            * Returns the first user notification event in the ordered set where userId = &#63; and archived = &#63;.
814            *
815            * @param userId the user ID
816            * @param archived the archived
817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
818            * @return the first matching user notification event
819            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
820            */
821            public UserNotificationEvent findByU_A_First(long userId, boolean archived,
822                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
823                    throws com.liferay.portal.NoSuchUserNotificationEventException;
824    
825            /**
826            * Returns the first user notification event in the ordered set where userId = &#63; and archived = &#63;.
827            *
828            * @param userId the user ID
829            * @param archived the archived
830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
831            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
832            */
833            public UserNotificationEvent fetchByU_A_First(long userId,
834                    boolean archived,
835                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
836    
837            /**
838            * Returns the last user notification event in the ordered set where userId = &#63; and archived = &#63;.
839            *
840            * @param userId the user ID
841            * @param archived the archived
842            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
843            * @return the last matching user notification event
844            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
845            */
846            public UserNotificationEvent findByU_A_Last(long userId, boolean archived,
847                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
848                    throws com.liferay.portal.NoSuchUserNotificationEventException;
849    
850            /**
851            * Returns the last user notification event in the ordered set where userId = &#63; and archived = &#63;.
852            *
853            * @param userId the user ID
854            * @param archived the archived
855            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
856            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
857            */
858            public UserNotificationEvent fetchByU_A_Last(long userId, boolean archived,
859                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
860    
861            /**
862            * Returns the user notification events before and after the current user notification event in the ordered set where userId = &#63; and archived = &#63;.
863            *
864            * @param userNotificationEventId the primary key of the current user notification event
865            * @param userId the user ID
866            * @param archived the archived
867            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
868            * @return the previous, current, and next user notification event
869            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
870            */
871            public UserNotificationEvent[] findByU_A_PrevAndNext(
872                    long userNotificationEventId, long userId, boolean archived,
873                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
874                    throws com.liferay.portal.NoSuchUserNotificationEventException;
875    
876            /**
877            * Removes all the user notification events where userId = &#63; and archived = &#63; from the database.
878            *
879            * @param userId the user ID
880            * @param archived the archived
881            */
882            public void removeByU_A(long userId, boolean archived);
883    
884            /**
885            * Returns the number of user notification events where userId = &#63; and archived = &#63;.
886            *
887            * @param userId the user ID
888            * @param archived the archived
889            * @return the number of matching user notification events
890            */
891            public int countByU_A(long userId, boolean archived);
892    
893            /**
894            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
895            *
896            * @param userId the user ID
897            * @param deliveryType the delivery type
898            * @param delivered the delivered
899            * @return the matching user notification events
900            */
901            public java.util.List<UserNotificationEvent> findByU_DT_D(long userId,
902                    int deliveryType, boolean delivered);
903    
904            /**
905            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
906            *
907            * <p>
908            * 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.
909            * </p>
910            *
911            * @param userId the user ID
912            * @param deliveryType the delivery type
913            * @param delivered the delivered
914            * @param start the lower bound of the range of user notification events
915            * @param end the upper bound of the range of user notification events (not inclusive)
916            * @return the range of matching user notification events
917            */
918            public java.util.List<UserNotificationEvent> findByU_DT_D(long userId,
919                    int deliveryType, boolean delivered, int start, int end);
920    
921            /**
922            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
923            *
924            * <p>
925            * 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.
926            * </p>
927            *
928            * @param userId the user ID
929            * @param deliveryType the delivery type
930            * @param delivered the delivered
931            * @param start the lower bound of the range of user notification events
932            * @param end the upper bound of the range of user notification events (not inclusive)
933            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
934            * @return the ordered range of matching user notification events
935            */
936            public java.util.List<UserNotificationEvent> findByU_DT_D(long userId,
937                    int deliveryType, boolean delivered, int start, int end,
938                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
939    
940            /**
941            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
942            *
943            * <p>
944            * 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.
945            * </p>
946            *
947            * @param userId the user ID
948            * @param deliveryType the delivery type
949            * @param delivered the delivered
950            * @param start the lower bound of the range of user notification events
951            * @param end the upper bound of the range of user notification events (not inclusive)
952            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
953            * @param retrieveFromCache whether to retrieve from the finder cache
954            * @return the ordered range of matching user notification events
955            */
956            public java.util.List<UserNotificationEvent> findByU_DT_D(long userId,
957                    int deliveryType, boolean delivered, int start, int end,
958                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
959                    boolean retrieveFromCache);
960    
961            /**
962            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
963            *
964            * @param userId the user ID
965            * @param deliveryType the delivery type
966            * @param delivered the delivered
967            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
968            * @return the first matching user notification event
969            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
970            */
971            public UserNotificationEvent findByU_DT_D_First(long userId,
972                    int deliveryType, boolean delivered,
973                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
974                    throws com.liferay.portal.NoSuchUserNotificationEventException;
975    
976            /**
977            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
978            *
979            * @param userId the user ID
980            * @param deliveryType the delivery type
981            * @param delivered the delivered
982            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
983            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
984            */
985            public UserNotificationEvent fetchByU_DT_D_First(long userId,
986                    int deliveryType, boolean delivered,
987                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
988    
989            /**
990            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
991            *
992            * @param userId the user ID
993            * @param deliveryType the delivery type
994            * @param delivered the delivered
995            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
996            * @return the last matching user notification event
997            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
998            */
999            public UserNotificationEvent findByU_DT_D_Last(long userId,
1000                    int deliveryType, boolean delivered,
1001                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1002                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1003    
1004            /**
1005            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1006            *
1007            * @param userId the user ID
1008            * @param deliveryType the delivery type
1009            * @param delivered the delivered
1010            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1011            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1012            */
1013            public UserNotificationEvent fetchByU_DT_D_Last(long userId,
1014                    int deliveryType, boolean delivered,
1015                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1016    
1017            /**
1018            * 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;.
1019            *
1020            * @param userNotificationEventId the primary key of the current user notification event
1021            * @param userId the user ID
1022            * @param deliveryType the delivery type
1023            * @param delivered the delivered
1024            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1025            * @return the previous, current, and next user notification event
1026            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1027            */
1028            public UserNotificationEvent[] findByU_DT_D_PrevAndNext(
1029                    long userNotificationEventId, long userId, int deliveryType,
1030                    boolean delivered,
1031                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1032                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1033    
1034            /**
1035            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; from the database.
1036            *
1037            * @param userId the user ID
1038            * @param deliveryType the delivery type
1039            * @param delivered the delivered
1040            */
1041            public void removeByU_DT_D(long userId, int deliveryType, boolean delivered);
1042    
1043            /**
1044            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63;.
1045            *
1046            * @param userId the user ID
1047            * @param deliveryType the delivery type
1048            * @param delivered the delivered
1049            * @return the number of matching user notification events
1050            */
1051            public int countByU_DT_D(long userId, int deliveryType, boolean delivered);
1052    
1053            /**
1054            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1055            *
1056            * @param userId the user ID
1057            * @param deliveryType the delivery type
1058            * @param archived the archived
1059            * @return the matching user notification events
1060            */
1061            public java.util.List<UserNotificationEvent> findByU_DT_A(long userId,
1062                    int deliveryType, boolean archived);
1063    
1064            /**
1065            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1066            *
1067            * <p>
1068            * 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.
1069            * </p>
1070            *
1071            * @param userId the user ID
1072            * @param deliveryType the delivery type
1073            * @param archived the archived
1074            * @param start the lower bound of the range of user notification events
1075            * @param end the upper bound of the range of user notification events (not inclusive)
1076            * @return the range of matching user notification events
1077            */
1078            public java.util.List<UserNotificationEvent> findByU_DT_A(long userId,
1079                    int deliveryType, boolean archived, int start, int end);
1080    
1081            /**
1082            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1083            *
1084            * <p>
1085            * 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.
1086            * </p>
1087            *
1088            * @param userId the user ID
1089            * @param deliveryType the delivery type
1090            * @param archived the archived
1091            * @param start the lower bound of the range of user notification events
1092            * @param end the upper bound of the range of user notification events (not inclusive)
1093            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1094            * @return the ordered range of matching user notification events
1095            */
1096            public java.util.List<UserNotificationEvent> findByU_DT_A(long userId,
1097                    int deliveryType, boolean archived, int start, int end,
1098                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1099    
1100            /**
1101            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1102            *
1103            * <p>
1104            * 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.
1105            * </p>
1106            *
1107            * @param userId the user ID
1108            * @param deliveryType the delivery type
1109            * @param archived the archived
1110            * @param start the lower bound of the range of user notification events
1111            * @param end the upper bound of the range of user notification events (not inclusive)
1112            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1113            * @param retrieveFromCache whether to retrieve from the finder cache
1114            * @return the ordered range of matching user notification events
1115            */
1116            public java.util.List<UserNotificationEvent> findByU_DT_A(long userId,
1117                    int deliveryType, boolean archived, int start, int end,
1118                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
1119                    boolean retrieveFromCache);
1120    
1121            /**
1122            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1123            *
1124            * @param userId the user ID
1125            * @param deliveryType the delivery type
1126            * @param archived the archived
1127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1128            * @return the first matching user notification event
1129            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1130            */
1131            public UserNotificationEvent findByU_DT_A_First(long userId,
1132                    int deliveryType, boolean archived,
1133                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1134                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1135    
1136            /**
1137            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1138            *
1139            * @param userId the user ID
1140            * @param deliveryType the delivery type
1141            * @param archived the archived
1142            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1143            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1144            */
1145            public UserNotificationEvent fetchByU_DT_A_First(long userId,
1146                    int deliveryType, boolean archived,
1147                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1148    
1149            /**
1150            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1151            *
1152            * @param userId the user ID
1153            * @param deliveryType the delivery type
1154            * @param archived the archived
1155            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1156            * @return the last matching user notification event
1157            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1158            */
1159            public UserNotificationEvent findByU_DT_A_Last(long userId,
1160                    int deliveryType, boolean archived,
1161                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1162                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1163    
1164            /**
1165            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1166            *
1167            * @param userId the user ID
1168            * @param deliveryType the delivery type
1169            * @param archived the archived
1170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1171            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1172            */
1173            public UserNotificationEvent fetchByU_DT_A_Last(long userId,
1174                    int deliveryType, boolean archived,
1175                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1176    
1177            /**
1178            * 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;.
1179            *
1180            * @param userNotificationEventId the primary key of the current user notification event
1181            * @param userId the user ID
1182            * @param deliveryType the delivery type
1183            * @param archived the archived
1184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1185            * @return the previous, current, and next user notification event
1186            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1187            */
1188            public UserNotificationEvent[] findByU_DT_A_PrevAndNext(
1189                    long userNotificationEventId, long userId, int deliveryType,
1190                    boolean archived,
1191                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1192                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1193    
1194            /**
1195            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63; from the database.
1196            *
1197            * @param userId the user ID
1198            * @param deliveryType the delivery type
1199            * @param archived the archived
1200            */
1201            public void removeByU_DT_A(long userId, int deliveryType, boolean archived);
1202    
1203            /**
1204            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and archived = &#63;.
1205            *
1206            * @param userId the user ID
1207            * @param deliveryType the delivery type
1208            * @param archived the archived
1209            * @return the number of matching user notification events
1210            */
1211            public int countByU_DT_A(long userId, int deliveryType, boolean archived);
1212    
1213            /**
1214            * Returns all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1215            *
1216            * @param userId the user ID
1217            * @param delivered the delivered
1218            * @param actionRequired the action required
1219            * @return the matching user notification events
1220            */
1221            public java.util.List<UserNotificationEvent> findByU_D_A(long userId,
1222                    boolean delivered, boolean actionRequired);
1223    
1224            /**
1225            * Returns a range of all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1226            *
1227            * <p>
1228            * 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.
1229            * </p>
1230            *
1231            * @param userId the user ID
1232            * @param delivered the delivered
1233            * @param actionRequired the action required
1234            * @param start the lower bound of the range of user notification events
1235            * @param end the upper bound of the range of user notification events (not inclusive)
1236            * @return the range of matching user notification events
1237            */
1238            public java.util.List<UserNotificationEvent> findByU_D_A(long userId,
1239                    boolean delivered, boolean actionRequired, int start, int end);
1240    
1241            /**
1242            * Returns an ordered range of all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1243            *
1244            * <p>
1245            * 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.
1246            * </p>
1247            *
1248            * @param userId the user ID
1249            * @param delivered the delivered
1250            * @param actionRequired the action required
1251            * @param start the lower bound of the range of user notification events
1252            * @param end the upper bound of the range of user notification events (not inclusive)
1253            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1254            * @return the ordered range of matching user notification events
1255            */
1256            public java.util.List<UserNotificationEvent> findByU_D_A(long userId,
1257                    boolean delivered, boolean actionRequired, int start, int end,
1258                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1259    
1260            /**
1261            * Returns an ordered range of all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1262            *
1263            * <p>
1264            * 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.
1265            * </p>
1266            *
1267            * @param userId the user ID
1268            * @param delivered the delivered
1269            * @param actionRequired the action required
1270            * @param start the lower bound of the range of user notification events
1271            * @param end the upper bound of the range of user notification events (not inclusive)
1272            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1273            * @param retrieveFromCache whether to retrieve from the finder cache
1274            * @return the ordered range of matching user notification events
1275            */
1276            public java.util.List<UserNotificationEvent> findByU_D_A(long userId,
1277                    boolean delivered, boolean actionRequired, int start, int end,
1278                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
1279                    boolean retrieveFromCache);
1280    
1281            /**
1282            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1283            *
1284            * @param userId the user ID
1285            * @param delivered the delivered
1286            * @param actionRequired the action required
1287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1288            * @return the first matching user notification event
1289            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1290            */
1291            public UserNotificationEvent findByU_D_A_First(long userId,
1292                    boolean delivered, boolean actionRequired,
1293                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1294                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1295    
1296            /**
1297            * Returns the first user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1298            *
1299            * @param userId the user ID
1300            * @param delivered the delivered
1301            * @param actionRequired the action required
1302            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1303            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1304            */
1305            public UserNotificationEvent fetchByU_D_A_First(long userId,
1306                    boolean delivered, boolean actionRequired,
1307                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1308    
1309            /**
1310            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1311            *
1312            * @param userId the user ID
1313            * @param delivered the delivered
1314            * @param actionRequired the action required
1315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1316            * @return the last matching user notification event
1317            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1318            */
1319            public UserNotificationEvent findByU_D_A_Last(long userId,
1320                    boolean delivered, boolean actionRequired,
1321                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1322                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1323    
1324            /**
1325            * Returns the last user notification event in the ordered set where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1326            *
1327            * @param userId the user ID
1328            * @param delivered the delivered
1329            * @param actionRequired the action required
1330            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1331            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1332            */
1333            public UserNotificationEvent fetchByU_D_A_Last(long userId,
1334                    boolean delivered, boolean actionRequired,
1335                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1336    
1337            /**
1338            * 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;.
1339            *
1340            * @param userNotificationEventId the primary key of the current user notification event
1341            * @param userId the user ID
1342            * @param delivered the delivered
1343            * @param actionRequired the action required
1344            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1345            * @return the previous, current, and next user notification event
1346            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1347            */
1348            public UserNotificationEvent[] findByU_D_A_PrevAndNext(
1349                    long userNotificationEventId, long userId, boolean delivered,
1350                    boolean actionRequired,
1351                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1352                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1353    
1354            /**
1355            * Removes all the user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63; from the database.
1356            *
1357            * @param userId the user ID
1358            * @param delivered the delivered
1359            * @param actionRequired the action required
1360            */
1361            public void removeByU_D_A(long userId, boolean delivered,
1362                    boolean actionRequired);
1363    
1364            /**
1365            * Returns the number of user notification events where userId = &#63; and delivered = &#63; and actionRequired = &#63;.
1366            *
1367            * @param userId the user ID
1368            * @param delivered the delivered
1369            * @param actionRequired the action required
1370            * @return the number of matching user notification events
1371            */
1372            public int countByU_D_A(long userId, boolean delivered,
1373                    boolean actionRequired);
1374    
1375            /**
1376            * Returns all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1377            *
1378            * @param userId the user ID
1379            * @param actionRequired the action required
1380            * @param archived the archived
1381            * @return the matching user notification events
1382            */
1383            public java.util.List<UserNotificationEvent> findByU_A_A(long userId,
1384                    boolean actionRequired, boolean archived);
1385    
1386            /**
1387            * Returns a range of all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1388            *
1389            * <p>
1390            * 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.
1391            * </p>
1392            *
1393            * @param userId the user ID
1394            * @param actionRequired the action required
1395            * @param archived the archived
1396            * @param start the lower bound of the range of user notification events
1397            * @param end the upper bound of the range of user notification events (not inclusive)
1398            * @return the range of matching user notification events
1399            */
1400            public java.util.List<UserNotificationEvent> findByU_A_A(long userId,
1401                    boolean actionRequired, boolean archived, int start, int end);
1402    
1403            /**
1404            * Returns an ordered range of all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1405            *
1406            * <p>
1407            * 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.
1408            * </p>
1409            *
1410            * @param userId the user ID
1411            * @param actionRequired the action required
1412            * @param archived the archived
1413            * @param start the lower bound of the range of user notification events
1414            * @param end the upper bound of the range of user notification events (not inclusive)
1415            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1416            * @return the ordered range of matching user notification events
1417            */
1418            public java.util.List<UserNotificationEvent> findByU_A_A(long userId,
1419                    boolean actionRequired, boolean archived, int start, int end,
1420                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1421    
1422            /**
1423            * Returns an ordered range of all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1424            *
1425            * <p>
1426            * 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.
1427            * </p>
1428            *
1429            * @param userId the user ID
1430            * @param actionRequired the action required
1431            * @param archived the archived
1432            * @param start the lower bound of the range of user notification events
1433            * @param end the upper bound of the range of user notification events (not inclusive)
1434            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1435            * @param retrieveFromCache whether to retrieve from the finder cache
1436            * @return the ordered range of matching user notification events
1437            */
1438            public java.util.List<UserNotificationEvent> findByU_A_A(long userId,
1439                    boolean actionRequired, boolean archived, int start, int end,
1440                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
1441                    boolean retrieveFromCache);
1442    
1443            /**
1444            * Returns the first user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1445            *
1446            * @param userId the user ID
1447            * @param actionRequired the action required
1448            * @param archived the archived
1449            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1450            * @return the first matching user notification event
1451            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1452            */
1453            public UserNotificationEvent findByU_A_A_First(long userId,
1454                    boolean actionRequired, boolean archived,
1455                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1456                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1457    
1458            /**
1459            * Returns the first user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1460            *
1461            * @param userId the user ID
1462            * @param actionRequired the action required
1463            * @param archived the archived
1464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1465            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1466            */
1467            public UserNotificationEvent fetchByU_A_A_First(long userId,
1468                    boolean actionRequired, boolean archived,
1469                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1470    
1471            /**
1472            * Returns the last user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1473            *
1474            * @param userId the user ID
1475            * @param actionRequired the action required
1476            * @param archived the archived
1477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1478            * @return the last matching user notification event
1479            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1480            */
1481            public UserNotificationEvent findByU_A_A_Last(long userId,
1482                    boolean actionRequired, boolean archived,
1483                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1484                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1485    
1486            /**
1487            * Returns the last user notification event in the ordered set where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1488            *
1489            * @param userId the user ID
1490            * @param actionRequired the action required
1491            * @param archived the archived
1492            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1493            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1494            */
1495            public UserNotificationEvent fetchByU_A_A_Last(long userId,
1496                    boolean actionRequired, boolean archived,
1497                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1498    
1499            /**
1500            * 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;.
1501            *
1502            * @param userNotificationEventId the primary key of the current user notification event
1503            * @param userId the user ID
1504            * @param actionRequired the action required
1505            * @param archived the archived
1506            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1507            * @return the previous, current, and next user notification event
1508            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1509            */
1510            public UserNotificationEvent[] findByU_A_A_PrevAndNext(
1511                    long userNotificationEventId, long userId, boolean actionRequired,
1512                    boolean archived,
1513                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1514                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1515    
1516            /**
1517            * Removes all the user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63; from the database.
1518            *
1519            * @param userId the user ID
1520            * @param actionRequired the action required
1521            * @param archived the archived
1522            */
1523            public void removeByU_A_A(long userId, boolean actionRequired,
1524                    boolean archived);
1525    
1526            /**
1527            * Returns the number of user notification events where userId = &#63; and actionRequired = &#63; and archived = &#63;.
1528            *
1529            * @param userId the user ID
1530            * @param actionRequired the action required
1531            * @param archived the archived
1532            * @return the number of matching user notification events
1533            */
1534            public int countByU_A_A(long userId, boolean actionRequired,
1535                    boolean archived);
1536    
1537            /**
1538            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1539            *
1540            * @param userId the user ID
1541            * @param deliveryType the delivery type
1542            * @param delivered the delivered
1543            * @param actionRequired the action required
1544            * @return the matching user notification events
1545            */
1546            public java.util.List<UserNotificationEvent> findByU_DT_D_A(long userId,
1547                    int deliveryType, boolean delivered, boolean actionRequired);
1548    
1549            /**
1550            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1551            *
1552            * <p>
1553            * 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.
1554            * </p>
1555            *
1556            * @param userId the user ID
1557            * @param deliveryType the delivery type
1558            * @param delivered the delivered
1559            * @param actionRequired the action required
1560            * @param start the lower bound of the range of user notification events
1561            * @param end the upper bound of the range of user notification events (not inclusive)
1562            * @return the range of matching user notification events
1563            */
1564            public java.util.List<UserNotificationEvent> findByU_DT_D_A(long userId,
1565                    int deliveryType, boolean delivered, boolean actionRequired, int start,
1566                    int end);
1567    
1568            /**
1569            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1570            *
1571            * <p>
1572            * 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.
1573            * </p>
1574            *
1575            * @param userId the user ID
1576            * @param deliveryType the delivery type
1577            * @param delivered the delivered
1578            * @param actionRequired the action required
1579            * @param start the lower bound of the range of user notification events
1580            * @param end the upper bound of the range of user notification events (not inclusive)
1581            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1582            * @return the ordered range of matching user notification events
1583            */
1584            public java.util.List<UserNotificationEvent> findByU_DT_D_A(long userId,
1585                    int deliveryType, boolean delivered, boolean actionRequired, int start,
1586                    int end,
1587                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1588    
1589            /**
1590            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1591            *
1592            * <p>
1593            * 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.
1594            * </p>
1595            *
1596            * @param userId the user ID
1597            * @param deliveryType the delivery type
1598            * @param delivered the delivered
1599            * @param actionRequired the action required
1600            * @param start the lower bound of the range of user notification events
1601            * @param end the upper bound of the range of user notification events (not inclusive)
1602            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1603            * @param retrieveFromCache whether to retrieve from the finder cache
1604            * @return the ordered range of matching user notification events
1605            */
1606            public java.util.List<UserNotificationEvent> findByU_DT_D_A(long userId,
1607                    int deliveryType, boolean delivered, boolean actionRequired, int start,
1608                    int end,
1609                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
1610                    boolean retrieveFromCache);
1611    
1612            /**
1613            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1614            *
1615            * @param userId the user ID
1616            * @param deliveryType the delivery type
1617            * @param delivered the delivered
1618            * @param actionRequired the action required
1619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1620            * @return the first matching user notification event
1621            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1622            */
1623            public UserNotificationEvent findByU_DT_D_A_First(long userId,
1624                    int deliveryType, boolean delivered, boolean actionRequired,
1625                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1626                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1627    
1628            /**
1629            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1630            *
1631            * @param userId the user ID
1632            * @param deliveryType the delivery type
1633            * @param delivered the delivered
1634            * @param actionRequired the action required
1635            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1636            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1637            */
1638            public UserNotificationEvent fetchByU_DT_D_A_First(long userId,
1639                    int deliveryType, boolean delivered, boolean actionRequired,
1640                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1641    
1642            /**
1643            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1644            *
1645            * @param userId the user ID
1646            * @param deliveryType the delivery type
1647            * @param delivered the delivered
1648            * @param actionRequired the action required
1649            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1650            * @return the last matching user notification event
1651            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1652            */
1653            public UserNotificationEvent findByU_DT_D_A_Last(long userId,
1654                    int deliveryType, boolean delivered, boolean actionRequired,
1655                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1656                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1657    
1658            /**
1659            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1660            *
1661            * @param userId the user ID
1662            * @param deliveryType the delivery type
1663            * @param delivered the delivered
1664            * @param actionRequired the action required
1665            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1666            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1667            */
1668            public UserNotificationEvent fetchByU_DT_D_A_Last(long userId,
1669                    int deliveryType, boolean delivered, boolean actionRequired,
1670                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1671    
1672            /**
1673            * 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;.
1674            *
1675            * @param userNotificationEventId the primary key of the current user notification event
1676            * @param userId the user ID
1677            * @param deliveryType the delivery type
1678            * @param delivered the delivered
1679            * @param actionRequired the action required
1680            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1681            * @return the previous, current, and next user notification event
1682            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1683            */
1684            public UserNotificationEvent[] findByU_DT_D_A_PrevAndNext(
1685                    long userNotificationEventId, long userId, int deliveryType,
1686                    boolean delivered, boolean actionRequired,
1687                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1688                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1689    
1690            /**
1691            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63; from the database.
1692            *
1693            * @param userId the user ID
1694            * @param deliveryType the delivery type
1695            * @param delivered the delivered
1696            * @param actionRequired the action required
1697            */
1698            public void removeByU_DT_D_A(long userId, int deliveryType,
1699                    boolean delivered, boolean actionRequired);
1700    
1701            /**
1702            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and delivered = &#63; and actionRequired = &#63;.
1703            *
1704            * @param userId the user ID
1705            * @param deliveryType the delivery type
1706            * @param delivered the delivered
1707            * @param actionRequired the action required
1708            * @return the number of matching user notification events
1709            */
1710            public int countByU_DT_D_A(long userId, int deliveryType,
1711                    boolean delivered, boolean actionRequired);
1712    
1713            /**
1714            * Returns all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1715            *
1716            * @param userId the user ID
1717            * @param deliveryType the delivery type
1718            * @param actionRequired the action required
1719            * @param archived the archived
1720            * @return the matching user notification events
1721            */
1722            public java.util.List<UserNotificationEvent> findByU_DT_A_A(long userId,
1723                    int deliveryType, boolean actionRequired, boolean archived);
1724    
1725            /**
1726            * Returns a range of all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1727            *
1728            * <p>
1729            * 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.
1730            * </p>
1731            *
1732            * @param userId the user ID
1733            * @param deliveryType the delivery type
1734            * @param actionRequired the action required
1735            * @param archived the archived
1736            * @param start the lower bound of the range of user notification events
1737            * @param end the upper bound of the range of user notification events (not inclusive)
1738            * @return the range of matching user notification events
1739            */
1740            public java.util.List<UserNotificationEvent> findByU_DT_A_A(long userId,
1741                    int deliveryType, boolean actionRequired, boolean archived, int start,
1742                    int end);
1743    
1744            /**
1745            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1746            *
1747            * <p>
1748            * 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.
1749            * </p>
1750            *
1751            * @param userId the user ID
1752            * @param deliveryType the delivery type
1753            * @param actionRequired the action required
1754            * @param archived the archived
1755            * @param start the lower bound of the range of user notification events
1756            * @param end the upper bound of the range of user notification events (not inclusive)
1757            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1758            * @return the ordered range of matching user notification events
1759            */
1760            public java.util.List<UserNotificationEvent> findByU_DT_A_A(long userId,
1761                    int deliveryType, boolean actionRequired, boolean archived, int start,
1762                    int end,
1763                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1764    
1765            /**
1766            * Returns an ordered range of all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1767            *
1768            * <p>
1769            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1770            * </p>
1771            *
1772            * @param userId the user ID
1773            * @param deliveryType the delivery type
1774            * @param actionRequired the action required
1775            * @param archived the archived
1776            * @param start the lower bound of the range of user notification events
1777            * @param end the upper bound of the range of user notification events (not inclusive)
1778            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1779            * @param retrieveFromCache whether to retrieve from the finder cache
1780            * @return the ordered range of matching user notification events
1781            */
1782            public java.util.List<UserNotificationEvent> findByU_DT_A_A(long userId,
1783                    int deliveryType, boolean actionRequired, boolean archived, int start,
1784                    int end,
1785                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
1786                    boolean retrieveFromCache);
1787    
1788            /**
1789            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1790            *
1791            * @param userId the user ID
1792            * @param deliveryType the delivery type
1793            * @param actionRequired the action required
1794            * @param archived the archived
1795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1796            * @return the first matching user notification event
1797            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1798            */
1799            public UserNotificationEvent findByU_DT_A_A_First(long userId,
1800                    int deliveryType, boolean actionRequired, boolean archived,
1801                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1802                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1803    
1804            /**
1805            * Returns the first user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1806            *
1807            * @param userId the user ID
1808            * @param deliveryType the delivery type
1809            * @param actionRequired the action required
1810            * @param archived the archived
1811            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1812            * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found
1813            */
1814            public UserNotificationEvent fetchByU_DT_A_A_First(long userId,
1815                    int deliveryType, boolean actionRequired, boolean archived,
1816                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1817    
1818            /**
1819            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1820            *
1821            * @param userId the user ID
1822            * @param deliveryType the delivery type
1823            * @param actionRequired the action required
1824            * @param archived the archived
1825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1826            * @return the last matching user notification event
1827            * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found
1828            */
1829            public UserNotificationEvent findByU_DT_A_A_Last(long userId,
1830                    int deliveryType, boolean actionRequired, boolean archived,
1831                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1832                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1833    
1834            /**
1835            * Returns the last user notification event in the ordered set where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1836            *
1837            * @param userId the user ID
1838            * @param deliveryType the delivery type
1839            * @param actionRequired the action required
1840            * @param archived the archived
1841            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1842            * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found
1843            */
1844            public UserNotificationEvent fetchByU_DT_A_A_Last(long userId,
1845                    int deliveryType, boolean actionRequired, boolean archived,
1846                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1847    
1848            /**
1849            * 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;.
1850            *
1851            * @param userNotificationEventId the primary key of the current user notification event
1852            * @param userId the user ID
1853            * @param deliveryType the delivery type
1854            * @param actionRequired the action required
1855            * @param archived the archived
1856            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1857            * @return the previous, current, and next user notification event
1858            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1859            */
1860            public UserNotificationEvent[] findByU_DT_A_A_PrevAndNext(
1861                    long userNotificationEventId, long userId, int deliveryType,
1862                    boolean actionRequired, boolean archived,
1863                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator)
1864                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1865    
1866            /**
1867            * Removes all the user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63; from the database.
1868            *
1869            * @param userId the user ID
1870            * @param deliveryType the delivery type
1871            * @param actionRequired the action required
1872            * @param archived the archived
1873            */
1874            public void removeByU_DT_A_A(long userId, int deliveryType,
1875                    boolean actionRequired, boolean archived);
1876    
1877            /**
1878            * Returns the number of user notification events where userId = &#63; and deliveryType = &#63; and actionRequired = &#63; and archived = &#63;.
1879            *
1880            * @param userId the user ID
1881            * @param deliveryType the delivery type
1882            * @param actionRequired the action required
1883            * @param archived the archived
1884            * @return the number of matching user notification events
1885            */
1886            public int countByU_DT_A_A(long userId, int deliveryType,
1887                    boolean actionRequired, boolean archived);
1888    
1889            /**
1890            * Caches the user notification event in the entity cache if it is enabled.
1891            *
1892            * @param userNotificationEvent the user notification event
1893            */
1894            public void cacheResult(UserNotificationEvent userNotificationEvent);
1895    
1896            /**
1897            * Caches the user notification events in the entity cache if it is enabled.
1898            *
1899            * @param userNotificationEvents the user notification events
1900            */
1901            public void cacheResult(
1902                    java.util.List<UserNotificationEvent> userNotificationEvents);
1903    
1904            /**
1905            * Creates a new user notification event with the primary key. Does not add the user notification event to the database.
1906            *
1907            * @param userNotificationEventId the primary key for the new user notification event
1908            * @return the new user notification event
1909            */
1910            public UserNotificationEvent create(long userNotificationEventId);
1911    
1912            /**
1913            * Removes the user notification event with the primary key from the database. Also notifies the appropriate model listeners.
1914            *
1915            * @param userNotificationEventId the primary key of the user notification event
1916            * @return the user notification event that was removed
1917            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1918            */
1919            public UserNotificationEvent remove(long userNotificationEventId)
1920                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1921    
1922            public UserNotificationEvent updateImpl(
1923                    UserNotificationEvent userNotificationEvent);
1924    
1925            /**
1926            * Returns the user notification event with the primary key or throws a {@link NoSuchUserNotificationEventException} if it could not be found.
1927            *
1928            * @param userNotificationEventId the primary key of the user notification event
1929            * @return the user notification event
1930            * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found
1931            */
1932            public UserNotificationEvent findByPrimaryKey(long userNotificationEventId)
1933                    throws com.liferay.portal.NoSuchUserNotificationEventException;
1934    
1935            /**
1936            * Returns the user notification event with the primary key or returns <code>null</code> if it could not be found.
1937            *
1938            * @param userNotificationEventId the primary key of the user notification event
1939            * @return the user notification event, or <code>null</code> if a user notification event with the primary key could not be found
1940            */
1941            public UserNotificationEvent fetchByPrimaryKey(long userNotificationEventId);
1942    
1943            @Override
1944            public java.util.Map<java.io.Serializable, UserNotificationEvent> fetchByPrimaryKeys(
1945                    java.util.Set<java.io.Serializable> primaryKeys);
1946    
1947            /**
1948            * Returns all the user notification events.
1949            *
1950            * @return the user notification events
1951            */
1952            public java.util.List<UserNotificationEvent> findAll();
1953    
1954            /**
1955            * Returns a range of all the user notification events.
1956            *
1957            * <p>
1958            * 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.
1959            * </p>
1960            *
1961            * @param start the lower bound of the range of user notification events
1962            * @param end the upper bound of the range of user notification events (not inclusive)
1963            * @return the range of user notification events
1964            */
1965            public java.util.List<UserNotificationEvent> findAll(int start, int end);
1966    
1967            /**
1968            * Returns an ordered range of all the user notification events.
1969            *
1970            * <p>
1971            * 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.
1972            * </p>
1973            *
1974            * @param start the lower bound of the range of user notification events
1975            * @param end the upper bound of the range of user notification events (not inclusive)
1976            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1977            * @return the ordered range of user notification events
1978            */
1979            public java.util.List<UserNotificationEvent> findAll(int start, int end,
1980                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator);
1981    
1982            /**
1983            * Returns an ordered range of all the user notification events.
1984            *
1985            * <p>
1986            * 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.
1987            * </p>
1988            *
1989            * @param start the lower bound of the range of user notification events
1990            * @param end the upper bound of the range of user notification events (not inclusive)
1991            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1992            * @param retrieveFromCache whether to retrieve from the finder cache
1993            * @return the ordered range of user notification events
1994            */
1995            public java.util.List<UserNotificationEvent> findAll(int start, int end,
1996                    com.liferay.portal.kernel.util.OrderByComparator<UserNotificationEvent> orderByComparator,
1997                    boolean retrieveFromCache);
1998    
1999            /**
2000            * Removes all the user notification events from the database.
2001            */
2002            public void removeAll();
2003    
2004            /**
2005            * Returns the number of user notification events.
2006            *
2007            * @return the number of user notification events
2008            */
2009            public int countAll();
2010    
2011            @Override
2012            public java.util.Set<java.lang.String> getBadColumnNames();
2013    }