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