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