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