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.exportimport.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.exportimport.model.ExportImportConfiguration;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the export import configuration service. This utility wraps {@link com.liferay.portlet.exportimport.service.persistence.impl.ExportImportConfigurationPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see ExportImportConfigurationPersistence
038     * @see com.liferay.portlet.exportimport.service.persistence.impl.ExportImportConfigurationPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class ExportImportConfigurationUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(
060                    ExportImportConfiguration exportImportConfiguration) {
061                    getPersistence().clearCache(exportImportConfiguration);
062            }
063    
064            /**
065             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
066             */
067            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
068                    return getPersistence().countWithDynamicQuery(dynamicQuery);
069            }
070    
071            /**
072             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
073             */
074            public static List<ExportImportConfiguration> findWithDynamicQuery(
075                    DynamicQuery dynamicQuery) {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
081             */
082            public static List<ExportImportConfiguration> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end) {
084                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
085            }
086    
087            /**
088             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
089             */
090            public static List<ExportImportConfiguration> findWithDynamicQuery(
091                    DynamicQuery dynamicQuery, int start, int end,
092                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
093                    return getPersistence()
094                                       .findWithDynamicQuery(dynamicQuery, start, end,
095                            orderByComparator);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
100             */
101            public static ExportImportConfiguration update(
102                    ExportImportConfiguration exportImportConfiguration) {
103                    return getPersistence().update(exportImportConfiguration);
104            }
105    
106            /**
107             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
108             */
109            public static ExportImportConfiguration update(
110                    ExportImportConfiguration exportImportConfiguration,
111                    ServiceContext serviceContext) {
112                    return getPersistence().update(exportImportConfiguration, serviceContext);
113            }
114    
115            /**
116            * Returns all the export import configurations where groupId = &#63;.
117            *
118            * @param groupId the group ID
119            * @return the matching export import configurations
120            */
121            public static List<ExportImportConfiguration> findByGroupId(long groupId) {
122                    return getPersistence().findByGroupId(groupId);
123            }
124    
125            /**
126            * Returns a range of all the export import configurations where groupId = &#63;.
127            *
128            * <p>
129            * 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 ExportImportConfigurationModelImpl}. 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.
130            * </p>
131            *
132            * @param groupId the group ID
133            * @param start the lower bound of the range of export import configurations
134            * @param end the upper bound of the range of export import configurations (not inclusive)
135            * @return the range of matching export import configurations
136            */
137            public static List<ExportImportConfiguration> findByGroupId(long groupId,
138                    int start, int end) {
139                    return getPersistence().findByGroupId(groupId, start, end);
140            }
141    
142            /**
143            * Returns an ordered range of all the export import configurations where groupId = &#63;.
144            *
145            * <p>
146            * 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 ExportImportConfigurationModelImpl}. 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.
147            * </p>
148            *
149            * @param groupId the group ID
150            * @param start the lower bound of the range of export import configurations
151            * @param end the upper bound of the range of export import configurations (not inclusive)
152            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
153            * @return the ordered range of matching export import configurations
154            */
155            public static List<ExportImportConfiguration> findByGroupId(long groupId,
156                    int start, int end,
157                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
158                    return getPersistence()
159                                       .findByGroupId(groupId, start, end, orderByComparator);
160            }
161    
162            /**
163            * Returns an ordered range of all the export import configurations where groupId = &#63;.
164            *
165            * <p>
166            * 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 ExportImportConfigurationModelImpl}. 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.
167            * </p>
168            *
169            * @param groupId the group ID
170            * @param start the lower bound of the range of export import configurations
171            * @param end the upper bound of the range of export import configurations (not inclusive)
172            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
173            * @param retrieveFromCache whether to retrieve from the finder cache
174            * @return the ordered range of matching export import configurations
175            */
176            public static List<ExportImportConfiguration> findByGroupId(long groupId,
177                    int start, int end,
178                    OrderByComparator<ExportImportConfiguration> orderByComparator,
179                    boolean retrieveFromCache) {
180                    return getPersistence()
181                                       .findByGroupId(groupId, start, end, orderByComparator,
182                            retrieveFromCache);
183            }
184    
185            /**
186            * Returns the first export import configuration in the ordered set where groupId = &#63;.
187            *
188            * @param groupId the group ID
189            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
190            * @return the first matching export import configuration
191            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
192            */
193            public static ExportImportConfiguration findByGroupId_First(long groupId,
194                    OrderByComparator<ExportImportConfiguration> orderByComparator)
195                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
196                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
197            }
198    
199            /**
200            * Returns the first export import configuration in the ordered set where groupId = &#63;.
201            *
202            * @param groupId the group ID
203            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
204            * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
205            */
206            public static ExportImportConfiguration fetchByGroupId_First(long groupId,
207                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
208                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
209            }
210    
211            /**
212            * Returns the last export import configuration in the ordered set where groupId = &#63;.
213            *
214            * @param groupId the group ID
215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
216            * @return the last matching export import configuration
217            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
218            */
219            public static ExportImportConfiguration findByGroupId_Last(long groupId,
220                    OrderByComparator<ExportImportConfiguration> orderByComparator)
221                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
222                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
223            }
224    
225            /**
226            * Returns the last export import configuration in the ordered set where groupId = &#63;.
227            *
228            * @param groupId the group ID
229            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
230            * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
231            */
232            public static ExportImportConfiguration fetchByGroupId_Last(long groupId,
233                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
234                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
235            }
236    
237            /**
238            * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = &#63;.
239            *
240            * @param exportImportConfigurationId the primary key of the current export import configuration
241            * @param groupId the group ID
242            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
243            * @return the previous, current, and next export import configuration
244            * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found
245            */
246            public static ExportImportConfiguration[] findByGroupId_PrevAndNext(
247                    long exportImportConfigurationId, long groupId,
248                    OrderByComparator<ExportImportConfiguration> orderByComparator)
249                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
250                    return getPersistence()
251                                       .findByGroupId_PrevAndNext(exportImportConfigurationId,
252                            groupId, orderByComparator);
253            }
254    
255            /**
256            * Removes all the export import configurations where groupId = &#63; from the database.
257            *
258            * @param groupId the group ID
259            */
260            public static void removeByGroupId(long groupId) {
261                    getPersistence().removeByGroupId(groupId);
262            }
263    
264            /**
265            * Returns the number of export import configurations where groupId = &#63;.
266            *
267            * @param groupId the group ID
268            * @return the number of matching export import configurations
269            */
270            public static int countByGroupId(long groupId) {
271                    return getPersistence().countByGroupId(groupId);
272            }
273    
274            /**
275            * Returns all the export import configurations where companyId = &#63;.
276            *
277            * @param companyId the company ID
278            * @return the matching export import configurations
279            */
280            public static List<ExportImportConfiguration> findByCompanyId(
281                    long companyId) {
282                    return getPersistence().findByCompanyId(companyId);
283            }
284    
285            /**
286            * Returns a range of all the export import configurations where companyId = &#63;.
287            *
288            * <p>
289            * 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 ExportImportConfigurationModelImpl}. 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.
290            * </p>
291            *
292            * @param companyId the company ID
293            * @param start the lower bound of the range of export import configurations
294            * @param end the upper bound of the range of export import configurations (not inclusive)
295            * @return the range of matching export import configurations
296            */
297            public static List<ExportImportConfiguration> findByCompanyId(
298                    long companyId, int start, int end) {
299                    return getPersistence().findByCompanyId(companyId, start, end);
300            }
301    
302            /**
303            * Returns an ordered range of all the export import configurations where companyId = &#63;.
304            *
305            * <p>
306            * 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 ExportImportConfigurationModelImpl}. 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.
307            * </p>
308            *
309            * @param companyId the company ID
310            * @param start the lower bound of the range of export import configurations
311            * @param end the upper bound of the range of export import configurations (not inclusive)
312            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
313            * @return the ordered range of matching export import configurations
314            */
315            public static List<ExportImportConfiguration> findByCompanyId(
316                    long companyId, int start, int end,
317                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
318                    return getPersistence()
319                                       .findByCompanyId(companyId, start, end, orderByComparator);
320            }
321    
322            /**
323            * Returns an ordered range of all the export import configurations where companyId = &#63;.
324            *
325            * <p>
326            * 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 ExportImportConfigurationModelImpl}. 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.
327            * </p>
328            *
329            * @param companyId the company ID
330            * @param start the lower bound of the range of export import configurations
331            * @param end the upper bound of the range of export import configurations (not inclusive)
332            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
333            * @param retrieveFromCache whether to retrieve from the finder cache
334            * @return the ordered range of matching export import configurations
335            */
336            public static List<ExportImportConfiguration> findByCompanyId(
337                    long companyId, int start, int end,
338                    OrderByComparator<ExportImportConfiguration> orderByComparator,
339                    boolean retrieveFromCache) {
340                    return getPersistence()
341                                       .findByCompanyId(companyId, start, end, orderByComparator,
342                            retrieveFromCache);
343            }
344    
345            /**
346            * Returns the first export import configuration in the ordered set where companyId = &#63;.
347            *
348            * @param companyId the company ID
349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
350            * @return the first matching export import configuration
351            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
352            */
353            public static ExportImportConfiguration findByCompanyId_First(
354                    long companyId,
355                    OrderByComparator<ExportImportConfiguration> orderByComparator)
356                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
357                    return getPersistence()
358                                       .findByCompanyId_First(companyId, orderByComparator);
359            }
360    
361            /**
362            * Returns the first export import configuration in the ordered set where companyId = &#63;.
363            *
364            * @param companyId the company ID
365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
366            * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
367            */
368            public static ExportImportConfiguration fetchByCompanyId_First(
369                    long companyId,
370                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
371                    return getPersistence()
372                                       .fetchByCompanyId_First(companyId, orderByComparator);
373            }
374    
375            /**
376            * Returns the last export import configuration in the ordered set where companyId = &#63;.
377            *
378            * @param companyId the company ID
379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
380            * @return the last matching export import configuration
381            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
382            */
383            public static ExportImportConfiguration findByCompanyId_Last(
384                    long companyId,
385                    OrderByComparator<ExportImportConfiguration> orderByComparator)
386                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
387                    return getPersistence()
388                                       .findByCompanyId_Last(companyId, orderByComparator);
389            }
390    
391            /**
392            * Returns the last export import configuration in the ordered set where companyId = &#63;.
393            *
394            * @param companyId the company ID
395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
396            * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
397            */
398            public static ExportImportConfiguration fetchByCompanyId_Last(
399                    long companyId,
400                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
401                    return getPersistence()
402                                       .fetchByCompanyId_Last(companyId, orderByComparator);
403            }
404    
405            /**
406            * Returns the export import configurations before and after the current export import configuration in the ordered set where companyId = &#63;.
407            *
408            * @param exportImportConfigurationId the primary key of the current export import configuration
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the previous, current, and next export import configuration
412            * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found
413            */
414            public static ExportImportConfiguration[] findByCompanyId_PrevAndNext(
415                    long exportImportConfigurationId, long companyId,
416                    OrderByComparator<ExportImportConfiguration> orderByComparator)
417                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
418                    return getPersistence()
419                                       .findByCompanyId_PrevAndNext(exportImportConfigurationId,
420                            companyId, orderByComparator);
421            }
422    
423            /**
424            * Removes all the export import configurations where companyId = &#63; from the database.
425            *
426            * @param companyId the company ID
427            */
428            public static void removeByCompanyId(long companyId) {
429                    getPersistence().removeByCompanyId(companyId);
430            }
431    
432            /**
433            * Returns the number of export import configurations where companyId = &#63;.
434            *
435            * @param companyId the company ID
436            * @return the number of matching export import configurations
437            */
438            public static int countByCompanyId(long companyId) {
439                    return getPersistence().countByCompanyId(companyId);
440            }
441    
442            /**
443            * Returns all the export import configurations where groupId = &#63; and type = &#63;.
444            *
445            * @param groupId the group ID
446            * @param type the type
447            * @return the matching export import configurations
448            */
449            public static List<ExportImportConfiguration> findByG_T(long groupId,
450                    int type) {
451                    return getPersistence().findByG_T(groupId, type);
452            }
453    
454            /**
455            * Returns a range of all the export import configurations where groupId = &#63; and type = &#63;.
456            *
457            * <p>
458            * 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 ExportImportConfigurationModelImpl}. 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.
459            * </p>
460            *
461            * @param groupId the group ID
462            * @param type the type
463            * @param start the lower bound of the range of export import configurations
464            * @param end the upper bound of the range of export import configurations (not inclusive)
465            * @return the range of matching export import configurations
466            */
467            public static List<ExportImportConfiguration> findByG_T(long groupId,
468                    int type, int start, int end) {
469                    return getPersistence().findByG_T(groupId, type, start, end);
470            }
471    
472            /**
473            * Returns an ordered range of all the export import configurations where groupId = &#63; and type = &#63;.
474            *
475            * <p>
476            * 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 ExportImportConfigurationModelImpl}. 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.
477            * </p>
478            *
479            * @param groupId the group ID
480            * @param type the type
481            * @param start the lower bound of the range of export import configurations
482            * @param end the upper bound of the range of export import configurations (not inclusive)
483            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
484            * @return the ordered range of matching export import configurations
485            */
486            public static List<ExportImportConfiguration> findByG_T(long groupId,
487                    int type, int start, int end,
488                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
489                    return getPersistence()
490                                       .findByG_T(groupId, type, start, end, orderByComparator);
491            }
492    
493            /**
494            * Returns an ordered range of all the export import configurations where groupId = &#63; and type = &#63;.
495            *
496            * <p>
497            * 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 ExportImportConfigurationModelImpl}. 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.
498            * </p>
499            *
500            * @param groupId the group ID
501            * @param type the type
502            * @param start the lower bound of the range of export import configurations
503            * @param end the upper bound of the range of export import configurations (not inclusive)
504            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
505            * @param retrieveFromCache whether to retrieve from the finder cache
506            * @return the ordered range of matching export import configurations
507            */
508            public static List<ExportImportConfiguration> findByG_T(long groupId,
509                    int type, int start, int end,
510                    OrderByComparator<ExportImportConfiguration> orderByComparator,
511                    boolean retrieveFromCache) {
512                    return getPersistence()
513                                       .findByG_T(groupId, type, start, end, orderByComparator,
514                            retrieveFromCache);
515            }
516    
517            /**
518            * Returns the first export import configuration in the ordered set where groupId = &#63; and type = &#63;.
519            *
520            * @param groupId the group ID
521            * @param type the type
522            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
523            * @return the first matching export import configuration
524            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
525            */
526            public static ExportImportConfiguration findByG_T_First(long groupId,
527                    int type, OrderByComparator<ExportImportConfiguration> orderByComparator)
528                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
529                    return getPersistence().findByG_T_First(groupId, type, orderByComparator);
530            }
531    
532            /**
533            * Returns the first export import configuration in the ordered set where groupId = &#63; and type = &#63;.
534            *
535            * @param groupId the group ID
536            * @param type the type
537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
538            * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
539            */
540            public static ExportImportConfiguration fetchByG_T_First(long groupId,
541                    int type, OrderByComparator<ExportImportConfiguration> orderByComparator) {
542                    return getPersistence()
543                                       .fetchByG_T_First(groupId, type, orderByComparator);
544            }
545    
546            /**
547            * Returns the last export import configuration in the ordered set where groupId = &#63; and type = &#63;.
548            *
549            * @param groupId the group ID
550            * @param type the type
551            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
552            * @return the last matching export import configuration
553            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
554            */
555            public static ExportImportConfiguration findByG_T_Last(long groupId,
556                    int type, OrderByComparator<ExportImportConfiguration> orderByComparator)
557                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
558                    return getPersistence().findByG_T_Last(groupId, type, orderByComparator);
559            }
560    
561            /**
562            * Returns the last export import configuration in the ordered set where groupId = &#63; and type = &#63;.
563            *
564            * @param groupId the group ID
565            * @param type the type
566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
567            * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
568            */
569            public static ExportImportConfiguration fetchByG_T_Last(long groupId,
570                    int type, OrderByComparator<ExportImportConfiguration> orderByComparator) {
571                    return getPersistence().fetchByG_T_Last(groupId, type, orderByComparator);
572            }
573    
574            /**
575            * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = &#63; and type = &#63;.
576            *
577            * @param exportImportConfigurationId the primary key of the current export import configuration
578            * @param groupId the group ID
579            * @param type the type
580            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
581            * @return the previous, current, and next export import configuration
582            * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found
583            */
584            public static ExportImportConfiguration[] findByG_T_PrevAndNext(
585                    long exportImportConfigurationId, long groupId, int type,
586                    OrderByComparator<ExportImportConfiguration> orderByComparator)
587                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
588                    return getPersistence()
589                                       .findByG_T_PrevAndNext(exportImportConfigurationId, groupId,
590                            type, orderByComparator);
591            }
592    
593            /**
594            * Removes all the export import configurations where groupId = &#63; and type = &#63; from the database.
595            *
596            * @param groupId the group ID
597            * @param type the type
598            */
599            public static void removeByG_T(long groupId, int type) {
600                    getPersistence().removeByG_T(groupId, type);
601            }
602    
603            /**
604            * Returns the number of export import configurations where groupId = &#63; and type = &#63;.
605            *
606            * @param groupId the group ID
607            * @param type the type
608            * @return the number of matching export import configurations
609            */
610            public static int countByG_T(long groupId, int type) {
611                    return getPersistence().countByG_T(groupId, type);
612            }
613    
614            /**
615            * Returns all the export import configurations where groupId = &#63; and status = &#63;.
616            *
617            * @param groupId the group ID
618            * @param status the status
619            * @return the matching export import configurations
620            */
621            public static List<ExportImportConfiguration> findByG_S(long groupId,
622                    int status) {
623                    return getPersistence().findByG_S(groupId, status);
624            }
625    
626            /**
627            * Returns a range of all the export import configurations where groupId = &#63; and status = &#63;.
628            *
629            * <p>
630            * 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 ExportImportConfigurationModelImpl}. 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.
631            * </p>
632            *
633            * @param groupId the group ID
634            * @param status the status
635            * @param start the lower bound of the range of export import configurations
636            * @param end the upper bound of the range of export import configurations (not inclusive)
637            * @return the range of matching export import configurations
638            */
639            public static List<ExportImportConfiguration> findByG_S(long groupId,
640                    int status, int start, int end) {
641                    return getPersistence().findByG_S(groupId, status, start, end);
642            }
643    
644            /**
645            * Returns an ordered range of all the export import configurations where groupId = &#63; and status = &#63;.
646            *
647            * <p>
648            * 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 ExportImportConfigurationModelImpl}. 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.
649            * </p>
650            *
651            * @param groupId the group ID
652            * @param status the status
653            * @param start the lower bound of the range of export import configurations
654            * @param end the upper bound of the range of export import configurations (not inclusive)
655            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
656            * @return the ordered range of matching export import configurations
657            */
658            public static List<ExportImportConfiguration> findByG_S(long groupId,
659                    int status, int start, int end,
660                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
661                    return getPersistence()
662                                       .findByG_S(groupId, status, start, end, orderByComparator);
663            }
664    
665            /**
666            * Returns an ordered range of all the export import configurations where groupId = &#63; and status = &#63;.
667            *
668            * <p>
669            * 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 ExportImportConfigurationModelImpl}. 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.
670            * </p>
671            *
672            * @param groupId the group ID
673            * @param status the status
674            * @param start the lower bound of the range of export import configurations
675            * @param end the upper bound of the range of export import configurations (not inclusive)
676            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
677            * @param retrieveFromCache whether to retrieve from the finder cache
678            * @return the ordered range of matching export import configurations
679            */
680            public static List<ExportImportConfiguration> findByG_S(long groupId,
681                    int status, int start, int end,
682                    OrderByComparator<ExportImportConfiguration> orderByComparator,
683                    boolean retrieveFromCache) {
684                    return getPersistence()
685                                       .findByG_S(groupId, status, start, end, orderByComparator,
686                            retrieveFromCache);
687            }
688    
689            /**
690            * Returns the first export import configuration in the ordered set where groupId = &#63; and status = &#63;.
691            *
692            * @param groupId the group ID
693            * @param status the status
694            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
695            * @return the first matching export import configuration
696            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
697            */
698            public static ExportImportConfiguration findByG_S_First(long groupId,
699                    int status,
700                    OrderByComparator<ExportImportConfiguration> orderByComparator)
701                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
702                    return getPersistence()
703                                       .findByG_S_First(groupId, status, orderByComparator);
704            }
705    
706            /**
707            * Returns the first export import configuration in the ordered set where groupId = &#63; and status = &#63;.
708            *
709            * @param groupId the group ID
710            * @param status the status
711            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
712            * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
713            */
714            public static ExportImportConfiguration fetchByG_S_First(long groupId,
715                    int status,
716                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
717                    return getPersistence()
718                                       .fetchByG_S_First(groupId, status, orderByComparator);
719            }
720    
721            /**
722            * Returns the last export import configuration in the ordered set where groupId = &#63; and status = &#63;.
723            *
724            * @param groupId the group ID
725            * @param status the status
726            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
727            * @return the last matching export import configuration
728            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
729            */
730            public static ExportImportConfiguration findByG_S_Last(long groupId,
731                    int status,
732                    OrderByComparator<ExportImportConfiguration> orderByComparator)
733                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
734                    return getPersistence()
735                                       .findByG_S_Last(groupId, status, orderByComparator);
736            }
737    
738            /**
739            * Returns the last export import configuration in the ordered set where groupId = &#63; and status = &#63;.
740            *
741            * @param groupId the group ID
742            * @param status the status
743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
744            * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
745            */
746            public static ExportImportConfiguration fetchByG_S_Last(long groupId,
747                    int status,
748                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
749                    return getPersistence()
750                                       .fetchByG_S_Last(groupId, status, orderByComparator);
751            }
752    
753            /**
754            * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = &#63; and status = &#63;.
755            *
756            * @param exportImportConfigurationId the primary key of the current export import configuration
757            * @param groupId the group ID
758            * @param status the status
759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
760            * @return the previous, current, and next export import configuration
761            * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found
762            */
763            public static ExportImportConfiguration[] findByG_S_PrevAndNext(
764                    long exportImportConfigurationId, long groupId, int status,
765                    OrderByComparator<ExportImportConfiguration> orderByComparator)
766                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
767                    return getPersistence()
768                                       .findByG_S_PrevAndNext(exportImportConfigurationId, groupId,
769                            status, orderByComparator);
770            }
771    
772            /**
773            * Removes all the export import configurations where groupId = &#63; and status = &#63; from the database.
774            *
775            * @param groupId the group ID
776            * @param status the status
777            */
778            public static void removeByG_S(long groupId, int status) {
779                    getPersistence().removeByG_S(groupId, status);
780            }
781    
782            /**
783            * Returns the number of export import configurations where groupId = &#63; and status = &#63;.
784            *
785            * @param groupId the group ID
786            * @param status the status
787            * @return the number of matching export import configurations
788            */
789            public static int countByG_S(long groupId, int status) {
790                    return getPersistence().countByG_S(groupId, status);
791            }
792    
793            /**
794            * Returns all the export import configurations where groupId = &#63; and type = &#63; and status = &#63;.
795            *
796            * @param groupId the group ID
797            * @param type the type
798            * @param status the status
799            * @return the matching export import configurations
800            */
801            public static List<ExportImportConfiguration> findByG_T_S(long groupId,
802                    int type, int status) {
803                    return getPersistence().findByG_T_S(groupId, type, status);
804            }
805    
806            /**
807            * Returns a range of all the export import configurations where groupId = &#63; and type = &#63; and status = &#63;.
808            *
809            * <p>
810            * 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 ExportImportConfigurationModelImpl}. 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.
811            * </p>
812            *
813            * @param groupId the group ID
814            * @param type the type
815            * @param status the status
816            * @param start the lower bound of the range of export import configurations
817            * @param end the upper bound of the range of export import configurations (not inclusive)
818            * @return the range of matching export import configurations
819            */
820            public static List<ExportImportConfiguration> findByG_T_S(long groupId,
821                    int type, int status, int start, int end) {
822                    return getPersistence().findByG_T_S(groupId, type, status, start, end);
823            }
824    
825            /**
826            * Returns an ordered range of all the export import configurations where groupId = &#63; and type = &#63; and status = &#63;.
827            *
828            * <p>
829            * 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 ExportImportConfigurationModelImpl}. 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.
830            * </p>
831            *
832            * @param groupId the group ID
833            * @param type the type
834            * @param status the status
835            * @param start the lower bound of the range of export import configurations
836            * @param end the upper bound of the range of export import configurations (not inclusive)
837            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
838            * @return the ordered range of matching export import configurations
839            */
840            public static List<ExportImportConfiguration> findByG_T_S(long groupId,
841                    int type, int status, int start, int end,
842                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
843                    return getPersistence()
844                                       .findByG_T_S(groupId, type, status, start, end,
845                            orderByComparator);
846            }
847    
848            /**
849            * Returns an ordered range of all the export import configurations where groupId = &#63; and type = &#63; and status = &#63;.
850            *
851            * <p>
852            * 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 ExportImportConfigurationModelImpl}. 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.
853            * </p>
854            *
855            * @param groupId the group ID
856            * @param type the type
857            * @param status the status
858            * @param start the lower bound of the range of export import configurations
859            * @param end the upper bound of the range of export import configurations (not inclusive)
860            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
861            * @param retrieveFromCache whether to retrieve from the finder cache
862            * @return the ordered range of matching export import configurations
863            */
864            public static List<ExportImportConfiguration> findByG_T_S(long groupId,
865                    int type, int status, int start, int end,
866                    OrderByComparator<ExportImportConfiguration> orderByComparator,
867                    boolean retrieveFromCache) {
868                    return getPersistence()
869                                       .findByG_T_S(groupId, type, status, start, end,
870                            orderByComparator, retrieveFromCache);
871            }
872    
873            /**
874            * Returns the first export import configuration in the ordered set where groupId = &#63; and type = &#63; and status = &#63;.
875            *
876            * @param groupId the group ID
877            * @param type the type
878            * @param status the status
879            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
880            * @return the first matching export import configuration
881            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
882            */
883            public static ExportImportConfiguration findByG_T_S_First(long groupId,
884                    int type, int status,
885                    OrderByComparator<ExportImportConfiguration> orderByComparator)
886                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
887                    return getPersistence()
888                                       .findByG_T_S_First(groupId, type, status, orderByComparator);
889            }
890    
891            /**
892            * Returns the first export import configuration in the ordered set where groupId = &#63; and type = &#63; and status = &#63;.
893            *
894            * @param groupId the group ID
895            * @param type the type
896            * @param status the status
897            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
898            * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
899            */
900            public static ExportImportConfiguration fetchByG_T_S_First(long groupId,
901                    int type, int status,
902                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
903                    return getPersistence()
904                                       .fetchByG_T_S_First(groupId, type, status, orderByComparator);
905            }
906    
907            /**
908            * Returns the last export import configuration in the ordered set where groupId = &#63; and type = &#63; and status = &#63;.
909            *
910            * @param groupId the group ID
911            * @param type the type
912            * @param status the status
913            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
914            * @return the last matching export import configuration
915            * @throws NoSuchConfigurationException if a matching export import configuration could not be found
916            */
917            public static ExportImportConfiguration findByG_T_S_Last(long groupId,
918                    int type, int status,
919                    OrderByComparator<ExportImportConfiguration> orderByComparator)
920                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
921                    return getPersistence()
922                                       .findByG_T_S_Last(groupId, type, status, orderByComparator);
923            }
924    
925            /**
926            * Returns the last export import configuration in the ordered set where groupId = &#63; and type = &#63; and status = &#63;.
927            *
928            * @param groupId the group ID
929            * @param type the type
930            * @param status the status
931            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
932            * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found
933            */
934            public static ExportImportConfiguration fetchByG_T_S_Last(long groupId,
935                    int type, int status,
936                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
937                    return getPersistence()
938                                       .fetchByG_T_S_Last(groupId, type, status, orderByComparator);
939            }
940    
941            /**
942            * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = &#63; and type = &#63; and status = &#63;.
943            *
944            * @param exportImportConfigurationId the primary key of the current export import configuration
945            * @param groupId the group ID
946            * @param type the type
947            * @param status the status
948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
949            * @return the previous, current, and next export import configuration
950            * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found
951            */
952            public static ExportImportConfiguration[] findByG_T_S_PrevAndNext(
953                    long exportImportConfigurationId, long groupId, int type, int status,
954                    OrderByComparator<ExportImportConfiguration> orderByComparator)
955                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
956                    return getPersistence()
957                                       .findByG_T_S_PrevAndNext(exportImportConfigurationId,
958                            groupId, type, status, orderByComparator);
959            }
960    
961            /**
962            * Removes all the export import configurations where groupId = &#63; and type = &#63; and status = &#63; from the database.
963            *
964            * @param groupId the group ID
965            * @param type the type
966            * @param status the status
967            */
968            public static void removeByG_T_S(long groupId, int type, int status) {
969                    getPersistence().removeByG_T_S(groupId, type, status);
970            }
971    
972            /**
973            * Returns the number of export import configurations where groupId = &#63; and type = &#63; and status = &#63;.
974            *
975            * @param groupId the group ID
976            * @param type the type
977            * @param status the status
978            * @return the number of matching export import configurations
979            */
980            public static int countByG_T_S(long groupId, int type, int status) {
981                    return getPersistence().countByG_T_S(groupId, type, status);
982            }
983    
984            /**
985            * Caches the export import configuration in the entity cache if it is enabled.
986            *
987            * @param exportImportConfiguration the export import configuration
988            */
989            public static void cacheResult(
990                    ExportImportConfiguration exportImportConfiguration) {
991                    getPersistence().cacheResult(exportImportConfiguration);
992            }
993    
994            /**
995            * Caches the export import configurations in the entity cache if it is enabled.
996            *
997            * @param exportImportConfigurations the export import configurations
998            */
999            public static void cacheResult(
1000                    List<ExportImportConfiguration> exportImportConfigurations) {
1001                    getPersistence().cacheResult(exportImportConfigurations);
1002            }
1003    
1004            /**
1005            * Creates a new export import configuration with the primary key. Does not add the export import configuration to the database.
1006            *
1007            * @param exportImportConfigurationId the primary key for the new export import configuration
1008            * @return the new export import configuration
1009            */
1010            public static ExportImportConfiguration create(
1011                    long exportImportConfigurationId) {
1012                    return getPersistence().create(exportImportConfigurationId);
1013            }
1014    
1015            /**
1016            * Removes the export import configuration with the primary key from the database. Also notifies the appropriate model listeners.
1017            *
1018            * @param exportImportConfigurationId the primary key of the export import configuration
1019            * @return the export import configuration that was removed
1020            * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found
1021            */
1022            public static ExportImportConfiguration remove(
1023                    long exportImportConfigurationId)
1024                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
1025                    return getPersistence().remove(exportImportConfigurationId);
1026            }
1027    
1028            public static ExportImportConfiguration updateImpl(
1029                    ExportImportConfiguration exportImportConfiguration) {
1030                    return getPersistence().updateImpl(exportImportConfiguration);
1031            }
1032    
1033            /**
1034            * Returns the export import configuration with the primary key or throws a {@link NoSuchConfigurationException} if it could not be found.
1035            *
1036            * @param exportImportConfigurationId the primary key of the export import configuration
1037            * @return the export import configuration
1038            * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found
1039            */
1040            public static ExportImportConfiguration findByPrimaryKey(
1041                    long exportImportConfigurationId)
1042                    throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException {
1043                    return getPersistence().findByPrimaryKey(exportImportConfigurationId);
1044            }
1045    
1046            /**
1047            * Returns the export import configuration with the primary key or returns <code>null</code> if it could not be found.
1048            *
1049            * @param exportImportConfigurationId the primary key of the export import configuration
1050            * @return the export import configuration, or <code>null</code> if a export import configuration with the primary key could not be found
1051            */
1052            public static ExportImportConfiguration fetchByPrimaryKey(
1053                    long exportImportConfigurationId) {
1054                    return getPersistence().fetchByPrimaryKey(exportImportConfigurationId);
1055            }
1056    
1057            public static java.util.Map<java.io.Serializable, ExportImportConfiguration> fetchByPrimaryKeys(
1058                    java.util.Set<java.io.Serializable> primaryKeys) {
1059                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1060            }
1061    
1062            /**
1063            * Returns all the export import configurations.
1064            *
1065            * @return the export import configurations
1066            */
1067            public static List<ExportImportConfiguration> findAll() {
1068                    return getPersistence().findAll();
1069            }
1070    
1071            /**
1072            * Returns a range of all the export import configurations.
1073            *
1074            * <p>
1075            * 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 ExportImportConfigurationModelImpl}. 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.
1076            * </p>
1077            *
1078            * @param start the lower bound of the range of export import configurations
1079            * @param end the upper bound of the range of export import configurations (not inclusive)
1080            * @return the range of export import configurations
1081            */
1082            public static List<ExportImportConfiguration> findAll(int start, int end) {
1083                    return getPersistence().findAll(start, end);
1084            }
1085    
1086            /**
1087            * Returns an ordered range of all the export import configurations.
1088            *
1089            * <p>
1090            * 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 ExportImportConfigurationModelImpl}. 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.
1091            * </p>
1092            *
1093            * @param start the lower bound of the range of export import configurations
1094            * @param end the upper bound of the range of export import configurations (not inclusive)
1095            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1096            * @return the ordered range of export import configurations
1097            */
1098            public static List<ExportImportConfiguration> findAll(int start, int end,
1099                    OrderByComparator<ExportImportConfiguration> orderByComparator) {
1100                    return getPersistence().findAll(start, end, orderByComparator);
1101            }
1102    
1103            /**
1104            * Returns an ordered range of all the export import configurations.
1105            *
1106            * <p>
1107            * 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 ExportImportConfigurationModelImpl}. 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.
1108            * </p>
1109            *
1110            * @param start the lower bound of the range of export import configurations
1111            * @param end the upper bound of the range of export import configurations (not inclusive)
1112            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1113            * @param retrieveFromCache whether to retrieve from the finder cache
1114            * @return the ordered range of export import configurations
1115            */
1116            public static List<ExportImportConfiguration> findAll(int start, int end,
1117                    OrderByComparator<ExportImportConfiguration> orderByComparator,
1118                    boolean retrieveFromCache) {
1119                    return getPersistence()
1120                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1121            }
1122    
1123            /**
1124            * Removes all the export import configurations from the database.
1125            */
1126            public static void removeAll() {
1127                    getPersistence().removeAll();
1128            }
1129    
1130            /**
1131            * Returns the number of export import configurations.
1132            *
1133            * @return the number of export import configurations
1134            */
1135            public static int countAll() {
1136                    return getPersistence().countAll();
1137            }
1138    
1139            public static java.util.Set<java.lang.String> getBadColumnNames() {
1140                    return getPersistence().getBadColumnNames();
1141            }
1142    
1143            public static ExportImportConfigurationPersistence getPersistence() {
1144                    if (_persistence == null) {
1145                            _persistence = (ExportImportConfigurationPersistence)PortalBeanLocatorUtil.locate(ExportImportConfigurationPersistence.class.getName());
1146    
1147                            ReferenceRegistry.registerReference(ExportImportConfigurationUtil.class,
1148                                    "_persistence");
1149                    }
1150    
1151                    return _persistence;
1152            }
1153    
1154            private static ExportImportConfigurationPersistence _persistence;
1155    }