001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.model.Team;
020    
021    /**
022     * The persistence interface for the team service.
023     *
024     * <p>
025     * Caching information and settings can be found in <code>portal.properties</code>
026     * </p>
027     *
028     * @author Brian Wing Shun Chan
029     * @see com.liferay.portal.service.persistence.impl.TeamPersistenceImpl
030     * @see TeamUtil
031     * @generated
032     */
033    @ProviderType
034    public interface TeamPersistence extends BasePersistence<Team> {
035            /*
036             * NOTE FOR DEVELOPERS:
037             *
038             * Never modify or reference this interface directly. Always use {@link TeamUtil} to access the team persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
039             */
040    
041            /**
042            * Returns all the teams where uuid = &#63;.
043            *
044            * @param uuid the uuid
045            * @return the matching teams
046            */
047            public java.util.List<Team> findByUuid(java.lang.String uuid);
048    
049            /**
050            * Returns a range of all the teams where uuid = &#63;.
051            *
052            * <p>
053            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TeamModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
054            * </p>
055            *
056            * @param uuid the uuid
057            * @param start the lower bound of the range of teams
058            * @param end the upper bound of the range of teams (not inclusive)
059            * @return the range of matching teams
060            */
061            public java.util.List<Team> findByUuid(java.lang.String uuid, int start,
062                    int end);
063    
064            /**
065            * Returns an ordered range of all the teams where uuid = &#63;.
066            *
067            * <p>
068            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TeamModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
069            * </p>
070            *
071            * @param uuid the uuid
072            * @param start the lower bound of the range of teams
073            * @param end the upper bound of the range of teams (not inclusive)
074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
075            * @return the ordered range of matching teams
076            */
077            public java.util.List<Team> findByUuid(java.lang.String uuid, int start,
078                    int end,
079                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
080    
081            /**
082            * Returns an ordered range of all the teams where uuid = &#63;.
083            *
084            * <p>
085            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TeamModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
086            * </p>
087            *
088            * @param uuid the uuid
089            * @param start the lower bound of the range of teams
090            * @param end the upper bound of the range of teams (not inclusive)
091            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
092            * @param retrieveFromCache whether to retrieve from the finder cache
093            * @return the ordered range of matching teams
094            */
095            public java.util.List<Team> findByUuid(java.lang.String uuid, int start,
096                    int end,
097                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator,
098                    boolean retrieveFromCache);
099    
100            /**
101            * Returns the first team in the ordered set where uuid = &#63;.
102            *
103            * @param uuid the uuid
104            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
105            * @return the first matching team
106            * @throws NoSuchTeamException if a matching team could not be found
107            */
108            public Team findByUuid_First(java.lang.String uuid,
109                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
110                    throws com.liferay.portal.exception.NoSuchTeamException;
111    
112            /**
113            * Returns the first team in the ordered set where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
117            * @return the first matching team, or <code>null</code> if a matching team could not be found
118            */
119            public Team fetchByUuid_First(java.lang.String uuid,
120                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
121    
122            /**
123            * Returns the last team in the ordered set where uuid = &#63;.
124            *
125            * @param uuid the uuid
126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
127            * @return the last matching team
128            * @throws NoSuchTeamException if a matching team could not be found
129            */
130            public Team findByUuid_Last(java.lang.String uuid,
131                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
132                    throws com.liferay.portal.exception.NoSuchTeamException;
133    
134            /**
135            * Returns the last team in the ordered set where uuid = &#63;.
136            *
137            * @param uuid the uuid
138            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
139            * @return the last matching team, or <code>null</code> if a matching team could not be found
140            */
141            public Team fetchByUuid_Last(java.lang.String uuid,
142                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
143    
144            /**
145            * Returns the teams before and after the current team in the ordered set where uuid = &#63;.
146            *
147            * @param teamId the primary key of the current team
148            * @param uuid the uuid
149            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
150            * @return the previous, current, and next team
151            * @throws NoSuchTeamException if a team with the primary key could not be found
152            */
153            public Team[] findByUuid_PrevAndNext(long teamId, java.lang.String uuid,
154                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
155                    throws com.liferay.portal.exception.NoSuchTeamException;
156    
157            /**
158            * Removes all the teams where uuid = &#63; from the database.
159            *
160            * @param uuid the uuid
161            */
162            public void removeByUuid(java.lang.String uuid);
163    
164            /**
165            * Returns the number of teams where uuid = &#63;.
166            *
167            * @param uuid the uuid
168            * @return the number of matching teams
169            */
170            public int countByUuid(java.lang.String uuid);
171    
172            /**
173            * Returns the team where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchTeamException} if it could not be found.
174            *
175            * @param uuid the uuid
176            * @param groupId the group ID
177            * @return the matching team
178            * @throws NoSuchTeamException if a matching team could not be found
179            */
180            public Team findByUUID_G(java.lang.String uuid, long groupId)
181                    throws com.liferay.portal.exception.NoSuchTeamException;
182    
183            /**
184            * Returns the team where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
185            *
186            * @param uuid the uuid
187            * @param groupId the group ID
188            * @return the matching team, or <code>null</code> if a matching team could not be found
189            */
190            public Team fetchByUUID_G(java.lang.String uuid, long groupId);
191    
192            /**
193            * Returns the team where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
194            *
195            * @param uuid the uuid
196            * @param groupId the group ID
197            * @param retrieveFromCache whether to retrieve from the finder cache
198            * @return the matching team, or <code>null</code> if a matching team could not be found
199            */
200            public Team fetchByUUID_G(java.lang.String uuid, long groupId,
201                    boolean retrieveFromCache);
202    
203            /**
204            * Removes the team where uuid = &#63; and groupId = &#63; from the database.
205            *
206            * @param uuid the uuid
207            * @param groupId the group ID
208            * @return the team that was removed
209            */
210            public Team removeByUUID_G(java.lang.String uuid, long groupId)
211                    throws com.liferay.portal.exception.NoSuchTeamException;
212    
213            /**
214            * Returns the number of teams where uuid = &#63; and groupId = &#63;.
215            *
216            * @param uuid the uuid
217            * @param groupId the group ID
218            * @return the number of matching teams
219            */
220            public int countByUUID_G(java.lang.String uuid, long groupId);
221    
222            /**
223            * Returns all the teams where uuid = &#63; and companyId = &#63;.
224            *
225            * @param uuid the uuid
226            * @param companyId the company ID
227            * @return the matching teams
228            */
229            public java.util.List<Team> findByUuid_C(java.lang.String uuid,
230                    long companyId);
231    
232            /**
233            * Returns a range of all the teams where uuid = &#63; and companyId = &#63;.
234            *
235            * <p>
236            * 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 TeamModelImpl}. 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.
237            * </p>
238            *
239            * @param uuid the uuid
240            * @param companyId the company ID
241            * @param start the lower bound of the range of teams
242            * @param end the upper bound of the range of teams (not inclusive)
243            * @return the range of matching teams
244            */
245            public java.util.List<Team> findByUuid_C(java.lang.String uuid,
246                    long companyId, int start, int end);
247    
248            /**
249            * Returns an ordered range of all the teams where uuid = &#63; and companyId = &#63;.
250            *
251            * <p>
252            * 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 TeamModelImpl}. 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.
253            * </p>
254            *
255            * @param uuid the uuid
256            * @param companyId the company ID
257            * @param start the lower bound of the range of teams
258            * @param end the upper bound of the range of teams (not inclusive)
259            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
260            * @return the ordered range of matching teams
261            */
262            public java.util.List<Team> findByUuid_C(java.lang.String uuid,
263                    long companyId, int start, int end,
264                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
265    
266            /**
267            * Returns an ordered range of all the teams where uuid = &#63; and companyId = &#63;.
268            *
269            * <p>
270            * 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 TeamModelImpl}. 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.
271            * </p>
272            *
273            * @param uuid the uuid
274            * @param companyId the company ID
275            * @param start the lower bound of the range of teams
276            * @param end the upper bound of the range of teams (not inclusive)
277            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
278            * @param retrieveFromCache whether to retrieve from the finder cache
279            * @return the ordered range of matching teams
280            */
281            public java.util.List<Team> findByUuid_C(java.lang.String uuid,
282                    long companyId, int start, int end,
283                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator,
284                    boolean retrieveFromCache);
285    
286            /**
287            * Returns the first team in the ordered set where uuid = &#63; and companyId = &#63;.
288            *
289            * @param uuid the uuid
290            * @param companyId the company ID
291            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
292            * @return the first matching team
293            * @throws NoSuchTeamException if a matching team could not be found
294            */
295            public Team findByUuid_C_First(java.lang.String uuid, long companyId,
296                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
297                    throws com.liferay.portal.exception.NoSuchTeamException;
298    
299            /**
300            * Returns the first team in the ordered set where uuid = &#63; and companyId = &#63;.
301            *
302            * @param uuid the uuid
303            * @param companyId the company ID
304            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
305            * @return the first matching team, or <code>null</code> if a matching team could not be found
306            */
307            public Team fetchByUuid_C_First(java.lang.String uuid, long companyId,
308                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
309    
310            /**
311            * Returns the last team in the ordered set where uuid = &#63; and companyId = &#63;.
312            *
313            * @param uuid the uuid
314            * @param companyId the company ID
315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
316            * @return the last matching team
317            * @throws NoSuchTeamException if a matching team could not be found
318            */
319            public Team findByUuid_C_Last(java.lang.String uuid, long companyId,
320                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
321                    throws com.liferay.portal.exception.NoSuchTeamException;
322    
323            /**
324            * Returns the last team in the ordered set where uuid = &#63; and companyId = &#63;.
325            *
326            * @param uuid the uuid
327            * @param companyId the company ID
328            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
329            * @return the last matching team, or <code>null</code> if a matching team could not be found
330            */
331            public Team fetchByUuid_C_Last(java.lang.String uuid, long companyId,
332                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
333    
334            /**
335            * Returns the teams before and after the current team in the ordered set where uuid = &#63; and companyId = &#63;.
336            *
337            * @param teamId the primary key of the current team
338            * @param uuid the uuid
339            * @param companyId the company ID
340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
341            * @return the previous, current, and next team
342            * @throws NoSuchTeamException if a team with the primary key could not be found
343            */
344            public Team[] findByUuid_C_PrevAndNext(long teamId, java.lang.String uuid,
345                    long companyId,
346                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
347                    throws com.liferay.portal.exception.NoSuchTeamException;
348    
349            /**
350            * Removes all the teams where uuid = &#63; and companyId = &#63; from the database.
351            *
352            * @param uuid the uuid
353            * @param companyId the company ID
354            */
355            public void removeByUuid_C(java.lang.String uuid, long companyId);
356    
357            /**
358            * Returns the number of teams where uuid = &#63; and companyId = &#63;.
359            *
360            * @param uuid the uuid
361            * @param companyId the company ID
362            * @return the number of matching teams
363            */
364            public int countByUuid_C(java.lang.String uuid, long companyId);
365    
366            /**
367            * Returns all the teams where groupId = &#63;.
368            *
369            * @param groupId the group ID
370            * @return the matching teams
371            */
372            public java.util.List<Team> findByGroupId(long groupId);
373    
374            /**
375            * Returns a range of all the teams where groupId = &#63;.
376            *
377            * <p>
378            * 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 TeamModelImpl}. 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.
379            * </p>
380            *
381            * @param groupId the group ID
382            * @param start the lower bound of the range of teams
383            * @param end the upper bound of the range of teams (not inclusive)
384            * @return the range of matching teams
385            */
386            public java.util.List<Team> findByGroupId(long groupId, int start, int end);
387    
388            /**
389            * Returns an ordered range of all the teams where groupId = &#63;.
390            *
391            * <p>
392            * 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 TeamModelImpl}. 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.
393            * </p>
394            *
395            * @param groupId the group ID
396            * @param start the lower bound of the range of teams
397            * @param end the upper bound of the range of teams (not inclusive)
398            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
399            * @return the ordered range of matching teams
400            */
401            public java.util.List<Team> findByGroupId(long groupId, int start, int end,
402                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
403    
404            /**
405            * Returns an ordered range of all the teams where groupId = &#63;.
406            *
407            * <p>
408            * 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 TeamModelImpl}. 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.
409            * </p>
410            *
411            * @param groupId the group ID
412            * @param start the lower bound of the range of teams
413            * @param end the upper bound of the range of teams (not inclusive)
414            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
415            * @param retrieveFromCache whether to retrieve from the finder cache
416            * @return the ordered range of matching teams
417            */
418            public java.util.List<Team> findByGroupId(long groupId, int start, int end,
419                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator,
420                    boolean retrieveFromCache);
421    
422            /**
423            * Returns the first team in the ordered set where groupId = &#63;.
424            *
425            * @param groupId the group ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching team
428            * @throws NoSuchTeamException if a matching team could not be found
429            */
430            public Team findByGroupId_First(long groupId,
431                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
432                    throws com.liferay.portal.exception.NoSuchTeamException;
433    
434            /**
435            * Returns the first team in the ordered set where groupId = &#63;.
436            *
437            * @param groupId the group ID
438            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
439            * @return the first matching team, or <code>null</code> if a matching team could not be found
440            */
441            public Team fetchByGroupId_First(long groupId,
442                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
443    
444            /**
445            * Returns the last team in the ordered set where groupId = &#63;.
446            *
447            * @param groupId the group ID
448            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
449            * @return the last matching team
450            * @throws NoSuchTeamException if a matching team could not be found
451            */
452            public Team findByGroupId_Last(long groupId,
453                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
454                    throws com.liferay.portal.exception.NoSuchTeamException;
455    
456            /**
457            * Returns the last team in the ordered set where groupId = &#63;.
458            *
459            * @param groupId the group ID
460            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
461            * @return the last matching team, or <code>null</code> if a matching team could not be found
462            */
463            public Team fetchByGroupId_Last(long groupId,
464                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
465    
466            /**
467            * Returns the teams before and after the current team in the ordered set where groupId = &#63;.
468            *
469            * @param teamId the primary key of the current team
470            * @param groupId the group ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the previous, current, and next team
473            * @throws NoSuchTeamException if a team with the primary key could not be found
474            */
475            public Team[] findByGroupId_PrevAndNext(long teamId, long groupId,
476                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
477                    throws com.liferay.portal.exception.NoSuchTeamException;
478    
479            /**
480            * Returns all the teams that the user has permission to view where groupId = &#63;.
481            *
482            * @param groupId the group ID
483            * @return the matching teams that the user has permission to view
484            */
485            public java.util.List<Team> filterFindByGroupId(long groupId);
486    
487            /**
488            * Returns a range of all the teams that the user has permission to view where groupId = &#63;.
489            *
490            * <p>
491            * 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 TeamModelImpl}. 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.
492            * </p>
493            *
494            * @param groupId the group ID
495            * @param start the lower bound of the range of teams
496            * @param end the upper bound of the range of teams (not inclusive)
497            * @return the range of matching teams that the user has permission to view
498            */
499            public java.util.List<Team> filterFindByGroupId(long groupId, int start,
500                    int end);
501    
502            /**
503            * Returns an ordered range of all the teams that the user has permissions to view where groupId = &#63;.
504            *
505            * <p>
506            * 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 TeamModelImpl}. 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.
507            * </p>
508            *
509            * @param groupId the group ID
510            * @param start the lower bound of the range of teams
511            * @param end the upper bound of the range of teams (not inclusive)
512            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
513            * @return the ordered range of matching teams that the user has permission to view
514            */
515            public java.util.List<Team> filterFindByGroupId(long groupId, int start,
516                    int end,
517                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
518    
519            /**
520            * Returns the teams before and after the current team in the ordered set of teams that the user has permission to view where groupId = &#63;.
521            *
522            * @param teamId the primary key of the current team
523            * @param groupId the group ID
524            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
525            * @return the previous, current, and next team
526            * @throws NoSuchTeamException if a team with the primary key could not be found
527            */
528            public Team[] filterFindByGroupId_PrevAndNext(long teamId, long groupId,
529                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator)
530                    throws com.liferay.portal.exception.NoSuchTeamException;
531    
532            /**
533            * Removes all the teams where groupId = &#63; from the database.
534            *
535            * @param groupId the group ID
536            */
537            public void removeByGroupId(long groupId);
538    
539            /**
540            * Returns the number of teams where groupId = &#63;.
541            *
542            * @param groupId the group ID
543            * @return the number of matching teams
544            */
545            public int countByGroupId(long groupId);
546    
547            /**
548            * Returns the number of teams that the user has permission to view where groupId = &#63;.
549            *
550            * @param groupId the group ID
551            * @return the number of matching teams that the user has permission to view
552            */
553            public int filterCountByGroupId(long groupId);
554    
555            /**
556            * Returns the team where groupId = &#63; and name = &#63; or throws a {@link NoSuchTeamException} if it could not be found.
557            *
558            * @param groupId the group ID
559            * @param name the name
560            * @return the matching team
561            * @throws NoSuchTeamException if a matching team could not be found
562            */
563            public Team findByG_N(long groupId, java.lang.String name)
564                    throws com.liferay.portal.exception.NoSuchTeamException;
565    
566            /**
567            * Returns the team where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
568            *
569            * @param groupId the group ID
570            * @param name the name
571            * @return the matching team, or <code>null</code> if a matching team could not be found
572            */
573            public Team fetchByG_N(long groupId, java.lang.String name);
574    
575            /**
576            * Returns the team where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
577            *
578            * @param groupId the group ID
579            * @param name the name
580            * @param retrieveFromCache whether to retrieve from the finder cache
581            * @return the matching team, or <code>null</code> if a matching team could not be found
582            */
583            public Team fetchByG_N(long groupId, java.lang.String name,
584                    boolean retrieveFromCache);
585    
586            /**
587            * Removes the team where groupId = &#63; and name = &#63; from the database.
588            *
589            * @param groupId the group ID
590            * @param name the name
591            * @return the team that was removed
592            */
593            public Team removeByG_N(long groupId, java.lang.String name)
594                    throws com.liferay.portal.exception.NoSuchTeamException;
595    
596            /**
597            * Returns the number of teams where groupId = &#63; and name = &#63;.
598            *
599            * @param groupId the group ID
600            * @param name the name
601            * @return the number of matching teams
602            */
603            public int countByG_N(long groupId, java.lang.String name);
604    
605            /**
606            * Caches the team in the entity cache if it is enabled.
607            *
608            * @param team the team
609            */
610            public void cacheResult(Team team);
611    
612            /**
613            * Caches the teams in the entity cache if it is enabled.
614            *
615            * @param teams the teams
616            */
617            public void cacheResult(java.util.List<Team> teams);
618    
619            /**
620            * Creates a new team with the primary key. Does not add the team to the database.
621            *
622            * @param teamId the primary key for the new team
623            * @return the new team
624            */
625            public Team create(long teamId);
626    
627            /**
628            * Removes the team with the primary key from the database. Also notifies the appropriate model listeners.
629            *
630            * @param teamId the primary key of the team
631            * @return the team that was removed
632            * @throws NoSuchTeamException if a team with the primary key could not be found
633            */
634            public Team remove(long teamId)
635                    throws com.liferay.portal.exception.NoSuchTeamException;
636    
637            public Team updateImpl(Team team);
638    
639            /**
640            * Returns the team with the primary key or throws a {@link NoSuchTeamException} if it could not be found.
641            *
642            * @param teamId the primary key of the team
643            * @return the team
644            * @throws NoSuchTeamException if a team with the primary key could not be found
645            */
646            public Team findByPrimaryKey(long teamId)
647                    throws com.liferay.portal.exception.NoSuchTeamException;
648    
649            /**
650            * Returns the team with the primary key or returns <code>null</code> if it could not be found.
651            *
652            * @param teamId the primary key of the team
653            * @return the team, or <code>null</code> if a team with the primary key could not be found
654            */
655            public Team fetchByPrimaryKey(long teamId);
656    
657            @Override
658            public java.util.Map<java.io.Serializable, Team> fetchByPrimaryKeys(
659                    java.util.Set<java.io.Serializable> primaryKeys);
660    
661            /**
662            * Returns all the teams.
663            *
664            * @return the teams
665            */
666            public java.util.List<Team> findAll();
667    
668            /**
669            * Returns a range of all the teams.
670            *
671            * <p>
672            * 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 TeamModelImpl}. 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.
673            * </p>
674            *
675            * @param start the lower bound of the range of teams
676            * @param end the upper bound of the range of teams (not inclusive)
677            * @return the range of teams
678            */
679            public java.util.List<Team> findAll(int start, int end);
680    
681            /**
682            * Returns an ordered range of all the teams.
683            *
684            * <p>
685            * 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 TeamModelImpl}. 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.
686            * </p>
687            *
688            * @param start the lower bound of the range of teams
689            * @param end the upper bound of the range of teams (not inclusive)
690            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
691            * @return the ordered range of teams
692            */
693            public java.util.List<Team> findAll(int start, int end,
694                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator);
695    
696            /**
697            * Returns an ordered range of all the teams.
698            *
699            * <p>
700            * 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 TeamModelImpl}. 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.
701            * </p>
702            *
703            * @param start the lower bound of the range of teams
704            * @param end the upper bound of the range of teams (not inclusive)
705            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
706            * @param retrieveFromCache whether to retrieve from the finder cache
707            * @return the ordered range of teams
708            */
709            public java.util.List<Team> findAll(int start, int end,
710                    com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator,
711                    boolean retrieveFromCache);
712    
713            /**
714            * Removes all the teams from the database.
715            */
716            public void removeAll();
717    
718            /**
719            * Returns the number of teams.
720            *
721            * @return the number of teams
722            */
723            public int countAll();
724    
725            /**
726            * Returns the primaryKeys of users associated with the team.
727            *
728            * @param pk the primary key of the team
729            * @return long[] of the primaryKeys of users associated with the team
730            */
731            public long[] getUserPrimaryKeys(long pk);
732    
733            /**
734            * Returns all the users associated with the team.
735            *
736            * @param pk the primary key of the team
737            * @return the users associated with the team
738            */
739            public java.util.List<com.liferay.portal.model.User> getUsers(long pk);
740    
741            /**
742            * Returns a range of all the users associated with the team.
743            *
744            * <p>
745            * 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 TeamModelImpl}. 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.
746            * </p>
747            *
748            * @param pk the primary key of the team
749            * @param start the lower bound of the range of teams
750            * @param end the upper bound of the range of teams (not inclusive)
751            * @return the range of users associated with the team
752            */
753            public java.util.List<com.liferay.portal.model.User> getUsers(long pk,
754                    int start, int end);
755    
756            /**
757            * Returns an ordered range of all the users associated with the team.
758            *
759            * <p>
760            * 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 TeamModelImpl}. 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.
761            * </p>
762            *
763            * @param pk the primary key of the team
764            * @param start the lower bound of the range of teams
765            * @param end the upper bound of the range of teams (not inclusive)
766            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
767            * @return the ordered range of users associated with the team
768            */
769            public java.util.List<com.liferay.portal.model.User> getUsers(long pk,
770                    int start, int end,
771                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator);
772    
773            /**
774            * Returns the number of users associated with the team.
775            *
776            * @param pk the primary key of the team
777            * @return the number of users associated with the team
778            */
779            public int getUsersSize(long pk);
780    
781            /**
782            * Returns <code>true</code> if the user is associated with the team.
783            *
784            * @param pk the primary key of the team
785            * @param userPK the primary key of the user
786            * @return <code>true</code> if the user is associated with the team; <code>false</code> otherwise
787            */
788            public boolean containsUser(long pk, long userPK);
789    
790            /**
791            * Returns <code>true</code> if the team has any users associated with it.
792            *
793            * @param pk the primary key of the team to check for associations with users
794            * @return <code>true</code> if the team has any users associated with it; <code>false</code> otherwise
795            */
796            public boolean containsUsers(long pk);
797    
798            /**
799            * Adds an association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
800            *
801            * @param pk the primary key of the team
802            * @param userPK the primary key of the user
803            */
804            public void addUser(long pk, long userPK);
805    
806            /**
807            * Adds an association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
808            *
809            * @param pk the primary key of the team
810            * @param user the user
811            */
812            public void addUser(long pk, com.liferay.portal.model.User user);
813    
814            /**
815            * Adds an association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
816            *
817            * @param pk the primary key of the team
818            * @param userPKs the primary keys of the users
819            */
820            public void addUsers(long pk, long[] userPKs);
821    
822            /**
823            * Adds an association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
824            *
825            * @param pk the primary key of the team
826            * @param users the users
827            */
828            public void addUsers(long pk,
829                    java.util.List<com.liferay.portal.model.User> users);
830    
831            /**
832            * Clears all associations between the team and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
833            *
834            * @param pk the primary key of the team to clear the associated users from
835            */
836            public void clearUsers(long pk);
837    
838            /**
839            * Removes the association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
840            *
841            * @param pk the primary key of the team
842            * @param userPK the primary key of the user
843            */
844            public void removeUser(long pk, long userPK);
845    
846            /**
847            * Removes the association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache.
848            *
849            * @param pk the primary key of the team
850            * @param user the user
851            */
852            public void removeUser(long pk, com.liferay.portal.model.User user);
853    
854            /**
855            * Removes the association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
856            *
857            * @param pk the primary key of the team
858            * @param userPKs the primary keys of the users
859            */
860            public void removeUsers(long pk, long[] userPKs);
861    
862            /**
863            * Removes the association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache.
864            *
865            * @param pk the primary key of the team
866            * @param users the users
867            */
868            public void removeUsers(long pk,
869                    java.util.List<com.liferay.portal.model.User> users);
870    
871            /**
872            * Sets the users associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
873            *
874            * @param pk the primary key of the team
875            * @param userPKs the primary keys of the users to be associated with the team
876            */
877            public void setUsers(long pk, long[] userPKs);
878    
879            /**
880            * Sets the users associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
881            *
882            * @param pk the primary key of the team
883            * @param users the users to be associated with the team
884            */
885            public void setUsers(long pk,
886                    java.util.List<com.liferay.portal.model.User> users);
887    
888            /**
889            * Returns the primaryKeys of user groups associated with the team.
890            *
891            * @param pk the primary key of the team
892            * @return long[] of the primaryKeys of user groups associated with the team
893            */
894            public long[] getUserGroupPrimaryKeys(long pk);
895    
896            /**
897            * Returns all the user groups associated with the team.
898            *
899            * @param pk the primary key of the team
900            * @return the user groups associated with the team
901            */
902            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
903                    long pk);
904    
905            /**
906            * Returns a range of all the user groups associated with the team.
907            *
908            * <p>
909            * 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 TeamModelImpl}. 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.
910            * </p>
911            *
912            * @param pk the primary key of the team
913            * @param start the lower bound of the range of teams
914            * @param end the upper bound of the range of teams (not inclusive)
915            * @return the range of user groups associated with the team
916            */
917            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
918                    long pk, int start, int end);
919    
920            /**
921            * Returns an ordered range of all the user groups associated with the team.
922            *
923            * <p>
924            * 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 TeamModelImpl}. 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.
925            * </p>
926            *
927            * @param pk the primary key of the team
928            * @param start the lower bound of the range of teams
929            * @param end the upper bound of the range of teams (not inclusive)
930            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
931            * @return the ordered range of user groups associated with the team
932            */
933            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
934                    long pk, int start, int end,
935                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator);
936    
937            /**
938            * Returns the number of user groups associated with the team.
939            *
940            * @param pk the primary key of the team
941            * @return the number of user groups associated with the team
942            */
943            public int getUserGroupsSize(long pk);
944    
945            /**
946            * Returns <code>true</code> if the user group is associated with the team.
947            *
948            * @param pk the primary key of the team
949            * @param userGroupPK the primary key of the user group
950            * @return <code>true</code> if the user group is associated with the team; <code>false</code> otherwise
951            */
952            public boolean containsUserGroup(long pk, long userGroupPK);
953    
954            /**
955            * Returns <code>true</code> if the team has any user groups associated with it.
956            *
957            * @param pk the primary key of the team to check for associations with user groups
958            * @return <code>true</code> if the team has any user groups associated with it; <code>false</code> otherwise
959            */
960            public boolean containsUserGroups(long pk);
961    
962            /**
963            * Adds an association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
964            *
965            * @param pk the primary key of the team
966            * @param userGroupPK the primary key of the user group
967            */
968            public void addUserGroup(long pk, long userGroupPK);
969    
970            /**
971            * Adds an association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
972            *
973            * @param pk the primary key of the team
974            * @param userGroup the user group
975            */
976            public void addUserGroup(long pk,
977                    com.liferay.portal.model.UserGroup userGroup);
978    
979            /**
980            * Adds an association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
981            *
982            * @param pk the primary key of the team
983            * @param userGroupPKs the primary keys of the user groups
984            */
985            public void addUserGroups(long pk, long[] userGroupPKs);
986    
987            /**
988            * Adds an association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
989            *
990            * @param pk the primary key of the team
991            * @param userGroups the user groups
992            */
993            public void addUserGroups(long pk,
994                    java.util.List<com.liferay.portal.model.UserGroup> userGroups);
995    
996            /**
997            * Clears all associations between the team and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
998            *
999            * @param pk the primary key of the team to clear the associated user groups from
1000            */
1001            public void clearUserGroups(long pk);
1002    
1003            /**
1004            * Removes the association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1005            *
1006            * @param pk the primary key of the team
1007            * @param userGroupPK the primary key of the user group
1008            */
1009            public void removeUserGroup(long pk, long userGroupPK);
1010    
1011            /**
1012            * Removes the association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1013            *
1014            * @param pk the primary key of the team
1015            * @param userGroup the user group
1016            */
1017            public void removeUserGroup(long pk,
1018                    com.liferay.portal.model.UserGroup userGroup);
1019    
1020            /**
1021            * Removes the association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1022            *
1023            * @param pk the primary key of the team
1024            * @param userGroupPKs the primary keys of the user groups
1025            */
1026            public void removeUserGroups(long pk, long[] userGroupPKs);
1027    
1028            /**
1029            * Removes the association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1030            *
1031            * @param pk the primary key of the team
1032            * @param userGroups the user groups
1033            */
1034            public void removeUserGroups(long pk,
1035                    java.util.List<com.liferay.portal.model.UserGroup> userGroups);
1036    
1037            /**
1038            * Sets the user groups associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1039            *
1040            * @param pk the primary key of the team
1041            * @param userGroupPKs the primary keys of the user groups to be associated with the team
1042            */
1043            public void setUserGroups(long pk, long[] userGroupPKs);
1044    
1045            /**
1046            * Sets the user groups associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1047            *
1048            * @param pk the primary key of the team
1049            * @param userGroups the user groups to be associated with the team
1050            */
1051            public void setUserGroups(long pk,
1052                    java.util.List<com.liferay.portal.model.UserGroup> userGroups);
1053    
1054            @Override
1055            public java.util.Set<java.lang.String> getBadColumnNames();
1056    }