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