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.portlet.softwarecatalog.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion;
022    
023    /**
024     * The persistence interface for the s c framework version service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCFrameworkVersionPersistenceImpl
032     * @see SCFrameworkVersionUtil
033     * @generated
034     */
035    @ProviderType
036    public interface SCFrameworkVersionPersistence extends BasePersistence<SCFrameworkVersion> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link SCFrameworkVersionUtil} to access the s c framework version persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the s c framework versions where groupId = &#63;.
045            *
046            * @param groupId the group ID
047            * @return the matching s c framework versions
048            */
049            public java.util.List<SCFrameworkVersion> findByGroupId(long groupId);
050    
051            /**
052            * Returns a range of all the s c framework versions where groupId = &#63;.
053            *
054            * <p>
055            * 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 SCFrameworkVersionModelImpl}. 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.
056            * </p>
057            *
058            * @param groupId the group ID
059            * @param start the lower bound of the range of s c framework versions
060            * @param end the upper bound of the range of s c framework versions (not inclusive)
061            * @return the range of matching s c framework versions
062            */
063            public java.util.List<SCFrameworkVersion> findByGroupId(long groupId,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the s c framework versions where groupId = &#63;.
068            *
069            * <p>
070            * 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 SCFrameworkVersionModelImpl}. 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.
071            * </p>
072            *
073            * @param groupId the group ID
074            * @param start the lower bound of the range of s c framework versions
075            * @param end the upper bound of the range of s c framework versions (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching s c framework versions
078            */
079            public java.util.List<SCFrameworkVersion> findByGroupId(long groupId,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
082    
083            /**
084            * Returns an ordered range of all the s c framework versions where groupId = &#63;.
085            *
086            * <p>
087            * 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 SCFrameworkVersionModelImpl}. 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.
088            * </p>
089            *
090            * @param groupId the group ID
091            * @param start the lower bound of the range of s c framework versions
092            * @param end the upper bound of the range of s c framework versions (not inclusive)
093            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
094            * @param retrieveFromCache whether to retrieve from the finder cache
095            * @return the ordered range of matching s c framework versions
096            */
097            public java.util.List<SCFrameworkVersion> findByGroupId(long groupId,
098                    int start, int end,
099                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator,
100                    boolean retrieveFromCache);
101    
102            /**
103            * Returns the first s c framework version in the ordered set where groupId = &#63;.
104            *
105            * @param groupId the group ID
106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
107            * @return the first matching s c framework version
108            * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found
109            */
110            public SCFrameworkVersion findByGroupId_First(long groupId,
111                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
112                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
113    
114            /**
115            * Returns the first s c framework version in the ordered set where groupId = &#63;.
116            *
117            * @param groupId the group ID
118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
119            * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found
120            */
121            public SCFrameworkVersion fetchByGroupId_First(long groupId,
122                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
123    
124            /**
125            * Returns the last s c framework version in the ordered set where groupId = &#63;.
126            *
127            * @param groupId the group ID
128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
129            * @return the last matching s c framework version
130            * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found
131            */
132            public SCFrameworkVersion findByGroupId_Last(long groupId,
133                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
134                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
135    
136            /**
137            * Returns the last s c framework version in the ordered set where groupId = &#63;.
138            *
139            * @param groupId the group ID
140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
141            * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found
142            */
143            public SCFrameworkVersion fetchByGroupId_Last(long groupId,
144                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
145    
146            /**
147            * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = &#63;.
148            *
149            * @param frameworkVersionId the primary key of the current s c framework version
150            * @param groupId the group ID
151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
152            * @return the previous, current, and next s c framework version
153            * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
154            */
155            public SCFrameworkVersion[] findByGroupId_PrevAndNext(
156                    long frameworkVersionId, long groupId,
157                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
158                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
159    
160            /**
161            * Returns all the s c framework versions that the user has permission to view where groupId = &#63;.
162            *
163            * @param groupId the group ID
164            * @return the matching s c framework versions that the user has permission to view
165            */
166            public java.util.List<SCFrameworkVersion> filterFindByGroupId(long groupId);
167    
168            /**
169            * Returns a range of all the s c framework versions that the user has permission to view where groupId = &#63;.
170            *
171            * <p>
172            * 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 SCFrameworkVersionModelImpl}. 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.
173            * </p>
174            *
175            * @param groupId the group ID
176            * @param start the lower bound of the range of s c framework versions
177            * @param end the upper bound of the range of s c framework versions (not inclusive)
178            * @return the range of matching s c framework versions that the user has permission to view
179            */
180            public java.util.List<SCFrameworkVersion> filterFindByGroupId(
181                    long groupId, int start, int end);
182    
183            /**
184            * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = &#63;.
185            *
186            * <p>
187            * 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 SCFrameworkVersionModelImpl}. 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.
188            * </p>
189            *
190            * @param groupId the group ID
191            * @param start the lower bound of the range of s c framework versions
192            * @param end the upper bound of the range of s c framework versions (not inclusive)
193            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
194            * @return the ordered range of matching s c framework versions that the user has permission to view
195            */
196            public java.util.List<SCFrameworkVersion> filterFindByGroupId(
197                    long groupId, int start, int end,
198                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
199    
200            /**
201            * Returns the s c framework versions before and after the current s c framework version in the ordered set of s c framework versions that the user has permission to view where groupId = &#63;.
202            *
203            * @param frameworkVersionId the primary key of the current s c framework version
204            * @param groupId the group ID
205            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
206            * @return the previous, current, and next s c framework version
207            * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
208            */
209            public SCFrameworkVersion[] filterFindByGroupId_PrevAndNext(
210                    long frameworkVersionId, long groupId,
211                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
212                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
213    
214            /**
215            * Removes all the s c framework versions where groupId = &#63; from the database.
216            *
217            * @param groupId the group ID
218            */
219            public void removeByGroupId(long groupId);
220    
221            /**
222            * Returns the number of s c framework versions where groupId = &#63;.
223            *
224            * @param groupId the group ID
225            * @return the number of matching s c framework versions
226            */
227            public int countByGroupId(long groupId);
228    
229            /**
230            * Returns the number of s c framework versions that the user has permission to view where groupId = &#63;.
231            *
232            * @param groupId the group ID
233            * @return the number of matching s c framework versions that the user has permission to view
234            */
235            public int filterCountByGroupId(long groupId);
236    
237            /**
238            * Returns all the s c framework versions where companyId = &#63;.
239            *
240            * @param companyId the company ID
241            * @return the matching s c framework versions
242            */
243            public java.util.List<SCFrameworkVersion> findByCompanyId(long companyId);
244    
245            /**
246            * Returns a range of all the s c framework versions where companyId = &#63;.
247            *
248            * <p>
249            * 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 SCFrameworkVersionModelImpl}. 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.
250            * </p>
251            *
252            * @param companyId the company ID
253            * @param start the lower bound of the range of s c framework versions
254            * @param end the upper bound of the range of s c framework versions (not inclusive)
255            * @return the range of matching s c framework versions
256            */
257            public java.util.List<SCFrameworkVersion> findByCompanyId(long companyId,
258                    int start, int end);
259    
260            /**
261            * Returns an ordered range of all the s c framework versions where companyId = &#63;.
262            *
263            * <p>
264            * 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 SCFrameworkVersionModelImpl}. 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.
265            * </p>
266            *
267            * @param companyId the company ID
268            * @param start the lower bound of the range of s c framework versions
269            * @param end the upper bound of the range of s c framework versions (not inclusive)
270            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
271            * @return the ordered range of matching s c framework versions
272            */
273            public java.util.List<SCFrameworkVersion> findByCompanyId(long companyId,
274                    int start, int end,
275                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
276    
277            /**
278            * Returns an ordered range of all the s c framework versions where companyId = &#63;.
279            *
280            * <p>
281            * 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 SCFrameworkVersionModelImpl}. 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.
282            * </p>
283            *
284            * @param companyId the company ID
285            * @param start the lower bound of the range of s c framework versions
286            * @param end the upper bound of the range of s c framework versions (not inclusive)
287            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
288            * @param retrieveFromCache whether to retrieve from the finder cache
289            * @return the ordered range of matching s c framework versions
290            */
291            public java.util.List<SCFrameworkVersion> findByCompanyId(long companyId,
292                    int start, int end,
293                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator,
294                    boolean retrieveFromCache);
295    
296            /**
297            * Returns the first s c framework version in the ordered set where companyId = &#63;.
298            *
299            * @param companyId the company ID
300            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
301            * @return the first matching s c framework version
302            * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found
303            */
304            public SCFrameworkVersion findByCompanyId_First(long companyId,
305                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
306                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
307    
308            /**
309            * Returns the first s c framework version in the ordered set where companyId = &#63;.
310            *
311            * @param companyId the company ID
312            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
313            * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found
314            */
315            public SCFrameworkVersion fetchByCompanyId_First(long companyId,
316                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
317    
318            /**
319            * Returns the last s c framework version in the ordered set where companyId = &#63;.
320            *
321            * @param companyId the company ID
322            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
323            * @return the last matching s c framework version
324            * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found
325            */
326            public SCFrameworkVersion findByCompanyId_Last(long companyId,
327                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
328                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
329    
330            /**
331            * Returns the last s c framework version in the ordered set where companyId = &#63;.
332            *
333            * @param companyId the company ID
334            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
335            * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found
336            */
337            public SCFrameworkVersion fetchByCompanyId_Last(long companyId,
338                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
339    
340            /**
341            * Returns the s c framework versions before and after the current s c framework version in the ordered set where companyId = &#63;.
342            *
343            * @param frameworkVersionId the primary key of the current s c framework version
344            * @param companyId the company ID
345            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
346            * @return the previous, current, and next s c framework version
347            * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
348            */
349            public SCFrameworkVersion[] findByCompanyId_PrevAndNext(
350                    long frameworkVersionId, long companyId,
351                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
352                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
353    
354            /**
355            * Removes all the s c framework versions where companyId = &#63; from the database.
356            *
357            * @param companyId the company ID
358            */
359            public void removeByCompanyId(long companyId);
360    
361            /**
362            * Returns the number of s c framework versions where companyId = &#63;.
363            *
364            * @param companyId the company ID
365            * @return the number of matching s c framework versions
366            */
367            public int countByCompanyId(long companyId);
368    
369            /**
370            * Returns all the s c framework versions where groupId = &#63; and active = &#63;.
371            *
372            * @param groupId the group ID
373            * @param active the active
374            * @return the matching s c framework versions
375            */
376            public java.util.List<SCFrameworkVersion> findByG_A(long groupId,
377                    boolean active);
378    
379            /**
380            * Returns a range of all the s c framework versions where groupId = &#63; and active = &#63;.
381            *
382            * <p>
383            * 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 SCFrameworkVersionModelImpl}. 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.
384            * </p>
385            *
386            * @param groupId the group ID
387            * @param active the active
388            * @param start the lower bound of the range of s c framework versions
389            * @param end the upper bound of the range of s c framework versions (not inclusive)
390            * @return the range of matching s c framework versions
391            */
392            public java.util.List<SCFrameworkVersion> findByG_A(long groupId,
393                    boolean active, int start, int end);
394    
395            /**
396            * Returns an ordered range of all the s c framework versions where groupId = &#63; and active = &#63;.
397            *
398            * <p>
399            * 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 SCFrameworkVersionModelImpl}. 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.
400            * </p>
401            *
402            * @param groupId the group ID
403            * @param active the active
404            * @param start the lower bound of the range of s c framework versions
405            * @param end the upper bound of the range of s c framework versions (not inclusive)
406            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
407            * @return the ordered range of matching s c framework versions
408            */
409            public java.util.List<SCFrameworkVersion> findByG_A(long groupId,
410                    boolean active, int start, int end,
411                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
412    
413            /**
414            * Returns an ordered range of all the s c framework versions where groupId = &#63; and active = &#63;.
415            *
416            * <p>
417            * 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 SCFrameworkVersionModelImpl}. 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.
418            * </p>
419            *
420            * @param groupId the group ID
421            * @param active the active
422            * @param start the lower bound of the range of s c framework versions
423            * @param end the upper bound of the range of s c framework versions (not inclusive)
424            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
425            * @param retrieveFromCache whether to retrieve from the finder cache
426            * @return the ordered range of matching s c framework versions
427            */
428            public java.util.List<SCFrameworkVersion> findByG_A(long groupId,
429                    boolean active, int start, int end,
430                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator,
431                    boolean retrieveFromCache);
432    
433            /**
434            * Returns the first s c framework version in the ordered set where groupId = &#63; and active = &#63;.
435            *
436            * @param groupId the group ID
437            * @param active the active
438            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
439            * @return the first matching s c framework version
440            * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found
441            */
442            public SCFrameworkVersion findByG_A_First(long groupId, boolean active,
443                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
444                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
445    
446            /**
447            * Returns the first s c framework version in the ordered set where groupId = &#63; and active = &#63;.
448            *
449            * @param groupId the group ID
450            * @param active the active
451            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
452            * @return the first matching s c framework version, or <code>null</code> if a matching s c framework version could not be found
453            */
454            public SCFrameworkVersion fetchByG_A_First(long groupId, boolean active,
455                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
456    
457            /**
458            * Returns the last s c framework version in the ordered set where groupId = &#63; and active = &#63;.
459            *
460            * @param groupId the group ID
461            * @param active the active
462            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
463            * @return the last matching s c framework version
464            * @throws NoSuchFrameworkVersionException if a matching s c framework version could not be found
465            */
466            public SCFrameworkVersion findByG_A_Last(long groupId, boolean active,
467                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
468                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
469    
470            /**
471            * Returns the last s c framework version in the ordered set where groupId = &#63; and active = &#63;.
472            *
473            * @param groupId the group ID
474            * @param active the active
475            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
476            * @return the last matching s c framework version, or <code>null</code> if a matching s c framework version could not be found
477            */
478            public SCFrameworkVersion fetchByG_A_Last(long groupId, boolean active,
479                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
480    
481            /**
482            * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = &#63; and active = &#63;.
483            *
484            * @param frameworkVersionId the primary key of the current s c framework version
485            * @param groupId the group ID
486            * @param active the active
487            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
488            * @return the previous, current, and next s c framework version
489            * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
490            */
491            public SCFrameworkVersion[] findByG_A_PrevAndNext(long frameworkVersionId,
492                    long groupId, boolean active,
493                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
494                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
495    
496            /**
497            * Returns all the s c framework versions that the user has permission to view where groupId = &#63; and active = &#63;.
498            *
499            * @param groupId the group ID
500            * @param active the active
501            * @return the matching s c framework versions that the user has permission to view
502            */
503            public java.util.List<SCFrameworkVersion> filterFindByG_A(long groupId,
504                    boolean active);
505    
506            /**
507            * Returns a range of all the s c framework versions that the user has permission to view where groupId = &#63; and active = &#63;.
508            *
509            * <p>
510            * 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 SCFrameworkVersionModelImpl}. 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.
511            * </p>
512            *
513            * @param groupId the group ID
514            * @param active the active
515            * @param start the lower bound of the range of s c framework versions
516            * @param end the upper bound of the range of s c framework versions (not inclusive)
517            * @return the range of matching s c framework versions that the user has permission to view
518            */
519            public java.util.List<SCFrameworkVersion> filterFindByG_A(long groupId,
520                    boolean active, int start, int end);
521    
522            /**
523            * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = &#63; and active = &#63;.
524            *
525            * <p>
526            * 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 SCFrameworkVersionModelImpl}. 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.
527            * </p>
528            *
529            * @param groupId the group ID
530            * @param active the active
531            * @param start the lower bound of the range of s c framework versions
532            * @param end the upper bound of the range of s c framework versions (not inclusive)
533            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
534            * @return the ordered range of matching s c framework versions that the user has permission to view
535            */
536            public java.util.List<SCFrameworkVersion> filterFindByG_A(long groupId,
537                    boolean active, int start, int end,
538                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
539    
540            /**
541            * Returns the s c framework versions before and after the current s c framework version in the ordered set of s c framework versions that the user has permission to view where groupId = &#63; and active = &#63;.
542            *
543            * @param frameworkVersionId the primary key of the current s c framework version
544            * @param groupId the group ID
545            * @param active the active
546            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
547            * @return the previous, current, and next s c framework version
548            * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
549            */
550            public SCFrameworkVersion[] filterFindByG_A_PrevAndNext(
551                    long frameworkVersionId, long groupId, boolean active,
552                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator)
553                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
554    
555            /**
556            * Removes all the s c framework versions where groupId = &#63; and active = &#63; from the database.
557            *
558            * @param groupId the group ID
559            * @param active the active
560            */
561            public void removeByG_A(long groupId, boolean active);
562    
563            /**
564            * Returns the number of s c framework versions where groupId = &#63; and active = &#63;.
565            *
566            * @param groupId the group ID
567            * @param active the active
568            * @return the number of matching s c framework versions
569            */
570            public int countByG_A(long groupId, boolean active);
571    
572            /**
573            * Returns the number of s c framework versions that the user has permission to view where groupId = &#63; and active = &#63;.
574            *
575            * @param groupId the group ID
576            * @param active the active
577            * @return the number of matching s c framework versions that the user has permission to view
578            */
579            public int filterCountByG_A(long groupId, boolean active);
580    
581            /**
582            * Caches the s c framework version in the entity cache if it is enabled.
583            *
584            * @param scFrameworkVersion the s c framework version
585            */
586            public void cacheResult(SCFrameworkVersion scFrameworkVersion);
587    
588            /**
589            * Caches the s c framework versions in the entity cache if it is enabled.
590            *
591            * @param scFrameworkVersions the s c framework versions
592            */
593            public void cacheResult(
594                    java.util.List<SCFrameworkVersion> scFrameworkVersions);
595    
596            /**
597            * Creates a new s c framework version with the primary key. Does not add the s c framework version to the database.
598            *
599            * @param frameworkVersionId the primary key for the new s c framework version
600            * @return the new s c framework version
601            */
602            public SCFrameworkVersion create(long frameworkVersionId);
603    
604            /**
605            * Removes the s c framework version with the primary key from the database. Also notifies the appropriate model listeners.
606            *
607            * @param frameworkVersionId the primary key of the s c framework version
608            * @return the s c framework version that was removed
609            * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
610            */
611            public SCFrameworkVersion remove(long frameworkVersionId)
612                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
613    
614            public SCFrameworkVersion updateImpl(SCFrameworkVersion scFrameworkVersion);
615    
616            /**
617            * Returns the s c framework version with the primary key or throws a {@link NoSuchFrameworkVersionException} if it could not be found.
618            *
619            * @param frameworkVersionId the primary key of the s c framework version
620            * @return the s c framework version
621            * @throws NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found
622            */
623            public SCFrameworkVersion findByPrimaryKey(long frameworkVersionId)
624                    throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException;
625    
626            /**
627            * Returns the s c framework version with the primary key or returns <code>null</code> if it could not be found.
628            *
629            * @param frameworkVersionId the primary key of the s c framework version
630            * @return the s c framework version, or <code>null</code> if a s c framework version with the primary key could not be found
631            */
632            public SCFrameworkVersion fetchByPrimaryKey(long frameworkVersionId);
633    
634            @Override
635            public java.util.Map<java.io.Serializable, SCFrameworkVersion> fetchByPrimaryKeys(
636                    java.util.Set<java.io.Serializable> primaryKeys);
637    
638            /**
639            * Returns all the s c framework versions.
640            *
641            * @return the s c framework versions
642            */
643            public java.util.List<SCFrameworkVersion> findAll();
644    
645            /**
646            * Returns a range of all the s c framework versions.
647            *
648            * <p>
649            * 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 SCFrameworkVersionModelImpl}. 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.
650            * </p>
651            *
652            * @param start the lower bound of the range of s c framework versions
653            * @param end the upper bound of the range of s c framework versions (not inclusive)
654            * @return the range of s c framework versions
655            */
656            public java.util.List<SCFrameworkVersion> findAll(int start, int end);
657    
658            /**
659            * Returns an ordered range of all the s c framework versions.
660            *
661            * <p>
662            * 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 SCFrameworkVersionModelImpl}. 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.
663            * </p>
664            *
665            * @param start the lower bound of the range of s c framework versions
666            * @param end the upper bound of the range of s c framework versions (not inclusive)
667            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
668            * @return the ordered range of s c framework versions
669            */
670            public java.util.List<SCFrameworkVersion> findAll(int start, int end,
671                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator);
672    
673            /**
674            * Returns an ordered range of all the s c framework versions.
675            *
676            * <p>
677            * 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 SCFrameworkVersionModelImpl}. 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.
678            * </p>
679            *
680            * @param start the lower bound of the range of s c framework versions
681            * @param end the upper bound of the range of s c framework versions (not inclusive)
682            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
683            * @param retrieveFromCache whether to retrieve from the finder cache
684            * @return the ordered range of s c framework versions
685            */
686            public java.util.List<SCFrameworkVersion> findAll(int start, int end,
687                    com.liferay.portal.kernel.util.OrderByComparator<SCFrameworkVersion> orderByComparator,
688                    boolean retrieveFromCache);
689    
690            /**
691            * Removes all the s c framework versions from the database.
692            */
693            public void removeAll();
694    
695            /**
696            * Returns the number of s c framework versions.
697            *
698            * @return the number of s c framework versions
699            */
700            public int countAll();
701    
702            /**
703            * Returns the primaryKeys of s c product versions associated with the s c framework version.
704            *
705            * @param pk the primary key of the s c framework version
706            * @return long[] of the primaryKeys of s c product versions associated with the s c framework version
707            */
708            public long[] getSCProductVersionPrimaryKeys(long pk);
709    
710            /**
711            * Returns all the s c product versions associated with the s c framework version.
712            *
713            * @param pk the primary key of the s c framework version
714            * @return the s c product versions associated with the s c framework version
715            */
716            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
717                    long pk);
718    
719            /**
720            * Returns a range of all the s c product versions associated with the s c framework version.
721            *
722            * <p>
723            * 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 SCFrameworkVersionModelImpl}. 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.
724            * </p>
725            *
726            * @param pk the primary key of the s c framework version
727            * @param start the lower bound of the range of s c framework versions
728            * @param end the upper bound of the range of s c framework versions (not inclusive)
729            * @return the range of s c product versions associated with the s c framework version
730            */
731            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
732                    long pk, int start, int end);
733    
734            /**
735            * Returns an ordered range of all the s c product versions associated with the s c framework version.
736            *
737            * <p>
738            * 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 SCFrameworkVersionModelImpl}. 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.
739            * </p>
740            *
741            * @param pk the primary key of the s c framework version
742            * @param start the lower bound of the range of s c framework versions
743            * @param end the upper bound of the range of s c framework versions (not inclusive)
744            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
745            * @return the ordered range of s c product versions associated with the s c framework version
746            */
747            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions(
748                    long pk, int start, int end,
749                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCProductVersion> orderByComparator);
750    
751            /**
752            * Returns the number of s c product versions associated with the s c framework version.
753            *
754            * @param pk the primary key of the s c framework version
755            * @return the number of s c product versions associated with the s c framework version
756            */
757            public int getSCProductVersionsSize(long pk);
758    
759            /**
760            * Returns <code>true</code> if the s c product version is associated with the s c framework version.
761            *
762            * @param pk the primary key of the s c framework version
763            * @param scProductVersionPK the primary key of the s c product version
764            * @return <code>true</code> if the s c product version is associated with the s c framework version; <code>false</code> otherwise
765            */
766            public boolean containsSCProductVersion(long pk, long scProductVersionPK);
767    
768            /**
769            * Returns <code>true</code> if the s c framework version has any s c product versions associated with it.
770            *
771            * @param pk the primary key of the s c framework version to check for associations with s c product versions
772            * @return <code>true</code> if the s c framework version has any s c product versions associated with it; <code>false</code> otherwise
773            */
774            public boolean containsSCProductVersions(long pk);
775    
776            /**
777            * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
778            *
779            * @param pk the primary key of the s c framework version
780            * @param scProductVersionPK the primary key of the s c product version
781            */
782            public void addSCProductVersion(long pk, long scProductVersionPK);
783    
784            /**
785            * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
786            *
787            * @param pk the primary key of the s c framework version
788            * @param scProductVersion the s c product version
789            */
790            public void addSCProductVersion(long pk,
791                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion);
792    
793            /**
794            * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
795            *
796            * @param pk the primary key of the s c framework version
797            * @param scProductVersionPKs the primary keys of the s c product versions
798            */
799            public void addSCProductVersions(long pk, long[] scProductVersionPKs);
800    
801            /**
802            * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
803            *
804            * @param pk the primary key of the s c framework version
805            * @param scProductVersions the s c product versions
806            */
807            public void addSCProductVersions(long pk,
808                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions);
809    
810            /**
811            * Clears all associations between the s c framework version and its s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
812            *
813            * @param pk the primary key of the s c framework version to clear the associated s c product versions from
814            */
815            public void clearSCProductVersions(long pk);
816    
817            /**
818            * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
819            *
820            * @param pk the primary key of the s c framework version
821            * @param scProductVersionPK the primary key of the s c product version
822            */
823            public void removeSCProductVersion(long pk, long scProductVersionPK);
824    
825            /**
826            * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache.
827            *
828            * @param pk the primary key of the s c framework version
829            * @param scProductVersion the s c product version
830            */
831            public void removeSCProductVersion(long pk,
832                    com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion);
833    
834            /**
835            * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
836            *
837            * @param pk the primary key of the s c framework version
838            * @param scProductVersionPKs the primary keys of the s c product versions
839            */
840            public void removeSCProductVersions(long pk, long[] scProductVersionPKs);
841    
842            /**
843            * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache.
844            *
845            * @param pk the primary key of the s c framework version
846            * @param scProductVersions the s c product versions
847            */
848            public void removeSCProductVersions(long pk,
849                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions);
850    
851            /**
852            * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
853            *
854            * @param pk the primary key of the s c framework version
855            * @param scProductVersionPKs the primary keys of the s c product versions to be associated with the s c framework version
856            */
857            public void setSCProductVersions(long pk, long[] scProductVersionPKs);
858    
859            /**
860            * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
861            *
862            * @param pk the primary key of the s c framework version
863            * @param scProductVersions the s c product versions to be associated with the s c framework version
864            */
865            public void setSCProductVersions(long pk,
866                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions);
867    
868            @Override
869            public java.util.Set<java.lang.String> getBadColumnNames();
870    }