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