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