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