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.kernel.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.exception.NoSuchTeamException;
020    import com.liferay.portal.kernel.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.kernel.model.User> getUsers(
739                    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.kernel.model.User> getUsers(
754                    long pk, 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.kernel.model.User> getUsers(
770                    long pk, int start, int end,
771                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.model.UserGroup> getUserGroups(
934                    long pk, int start, int end,
935                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.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.kernel.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.kernel.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.kernel.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.kernel.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.kernel.model.UserGroup> userGroups);
1053    
1054            @Override
1055            public java.util.Set<java.lang.String> getBadColumnNames();
1056    }