001/*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License").  You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
010 * or http://forgerock.org/license/CDDLv1.0.html.
011 * See the License for the specific language governing permissions
012 * and limitations under the License.
013 *
014 * When distributing Covered Code, include this CDDL HEADER in each
015 * file and include the License file at legal-notices/CDDLv1_0.txt.
016 * If applicable, add the following below this CDDL HEADER, with the
017 * fields enclosed by brackets "[]" replaced with your own identifying
018 * information:
019 *      Portions Copyright [yyyy] [name of copyright owner]
020 *
021 * CDDL HEADER END
022 *
023 *
024 *      Copyright 2008 Sun Microsystems, Inc.
025 */
026package org.forgerock.opendj.server.config.client;
027
028
029
030import java.util.Collection;
031import org.forgerock.opendj.config.client.ConcurrentModificationException;
032import org.forgerock.opendj.config.client.IllegalManagedObjectNameException;
033import org.forgerock.opendj.config.client.ManagedObjectDecodingException;
034import org.forgerock.opendj.config.client.OperationRejectedException;
035import org.forgerock.opendj.config.ConfigurationClient;
036import org.forgerock.opendj.config.DefinitionDecodingException;
037import org.forgerock.opendj.config.ManagedObjectDefinition;
038import org.forgerock.opendj.config.ManagedObjectNotFoundException;
039import org.forgerock.opendj.config.PropertyException;
040import org.forgerock.opendj.ldap.LdapException;
041import org.forgerock.opendj.server.config.server.AccountStatusNotificationHandlerCfg;
042import org.forgerock.opendj.server.config.server.AlertHandlerCfg;
043import org.forgerock.opendj.server.config.server.AttributeSyntaxCfg;
044import org.forgerock.opendj.server.config.server.AuthenticationPolicyCfg;
045import org.forgerock.opendj.server.config.server.BackendCfg;
046import org.forgerock.opendj.server.config.server.CertificateMapperCfg;
047import org.forgerock.opendj.server.config.server.ConnectionHandlerCfg;
048import org.forgerock.opendj.server.config.server.EntryCacheCfg;
049import org.forgerock.opendj.server.config.server.ExtendedOperationHandlerCfg;
050import org.forgerock.opendj.server.config.server.GroupImplementationCfg;
051import org.forgerock.opendj.server.config.server.IdentityMapperCfg;
052import org.forgerock.opendj.server.config.server.KeyManagerProviderCfg;
053import org.forgerock.opendj.server.config.server.LogPublisherCfg;
054import org.forgerock.opendj.server.config.server.LogRetentionPolicyCfg;
055import org.forgerock.opendj.server.config.server.LogRotationPolicyCfg;
056import org.forgerock.opendj.server.config.server.MatchingRuleCfg;
057import org.forgerock.opendj.server.config.server.MonitorProviderCfg;
058import org.forgerock.opendj.server.config.server.PasswordGeneratorCfg;
059import org.forgerock.opendj.server.config.server.PasswordStorageSchemeCfg;
060import org.forgerock.opendj.server.config.server.PasswordValidatorCfg;
061import org.forgerock.opendj.server.config.server.RootCfg;
062import org.forgerock.opendj.server.config.server.SASLMechanismHandlerCfg;
063import org.forgerock.opendj.server.config.server.SchemaProviderCfg;
064import org.forgerock.opendj.server.config.server.SynchronizationProviderCfg;
065import org.forgerock.opendj.server.config.server.TrustManagerProviderCfg;
066import org.forgerock.opendj.server.config.server.VirtualAttributeCfg;
067
068
069
070/**
071 * A client-side interface for reading and modifying Root settings.
072 * <p>
073 * The root configuration provides an entry point to the rest of the
074 * OpenDJ configuration.
075 */
076public interface RootCfgClient extends ConfigurationClient {
077
078  /**
079   * Get the configuration definition associated with this Root.
080   *
081   * @return Returns the configuration definition associated with this Root.
082   */
083  ManagedObjectDefinition<? extends RootCfgClient, ? extends RootCfg> definition();
084
085
086
087  /**
088   * Gets the Access Control Handler.
089   *
090   * @return Returns the Access Control Handler.
091   * @throws DefinitionDecodingException
092   *           If the Access Control Handler was found but its type
093   *           could not be determined.
094   * @throws ManagedObjectDecodingException
095   *           If the Access Control Handler was found but one or more
096   *           of its properties could not be decoded.
097   * @throws ManagedObjectNotFoundException
098   *           If the Access Control Handler could not be found on the
099   *           server.
100   * @throws ConcurrentModificationException
101   *           If this Root has been removed from the server by
102   *           another client.
103   * @throws LdapException
104   *           If any other error occurs.
105   */
106  AccessControlHandlerCfgClient getAccessControlHandler()
107      throws DefinitionDecodingException, ManagedObjectDecodingException,
108      ManagedObjectNotFoundException, ConcurrentModificationException,
109      LdapException;
110
111
112
113  /**
114   * Lists the Account Status Notification Handlers.
115   *
116   * @return Returns an array containing the names of the Account
117   *         Status Notification Handlers.
118   * @throws ConcurrentModificationException
119   *           If this Root has been removed from the server by
120   *           another client.
121   * @throws LdapException
122   *           If any other error occurs.
123   */
124  String[] listAccountStatusNotificationHandlers() throws ConcurrentModificationException,
125      LdapException;
126
127
128
129  /**
130   * Gets the named Account Status Notification Handler.
131   *
132   * @param name
133   *           The name of the Account Status Notification Handler to
134   *           retrieve.
135   * @return Returns the named Account Status Notification Handler.
136   * @throws DefinitionDecodingException
137   *           If the named Account Status Notification Handler was
138   *           found but its type could not be determined.
139   * @throws ManagedObjectDecodingException
140   *           If the named Account Status Notification Handler was
141   *           found but one or more of its properties could not be
142   *           decoded.
143   * @throws ManagedObjectNotFoundException
144   *           If the named Account Status Notification Handler was
145   *           not found on the server.
146   * @throws ConcurrentModificationException
147   *           If this Root has been removed from the server by
148   *           another client.
149   * @throws LdapException
150   *           If any other error occurs.
151   */
152  AccountStatusNotificationHandlerCfgClient getAccountStatusNotificationHandler(String name)
153      throws DefinitionDecodingException, ManagedObjectDecodingException,
154      ManagedObjectNotFoundException, ConcurrentModificationException,
155      LdapException;
156
157
158
159  /**
160   * Creates a new Account Status Notification Handler. The new
161   * Account Status Notification Handler will initially not contain any
162   * property values (including mandatory properties). Once the Account
163   * Status Notification Handler has been configured it can be added to
164   * the server using the {@link #commit()} method.
165   *
166   * @param <C>
167   *          The type of the Account Status Notification Handler
168   *          being created.
169   * @param d
170   *          The definition of the Account Status Notification
171   *          Handler to be created.
172   * @param name
173   *          The name of the new Account Status Notification Handler.
174   * @param exceptions
175   *          An optional collection in which to place any {@link
176   *          PropertyException}s that occurred whilst attempting to
177   *          determine the default values of the Account Status
178   *          Notification Handler. This argument can be
179   *          <code>null<code>.
180   * @return Returns a new Account Status Notification Handler
181   *         configuration instance.
182   * @throws IllegalManagedObjectNameException
183   *          If the name of the new Account Status Notification
184   *          Handler is invalid.
185   */
186  <C extends AccountStatusNotificationHandlerCfgClient> C createAccountStatusNotificationHandler(
187      ManagedObjectDefinition<C, ? extends AccountStatusNotificationHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
188
189
190
191  /**
192   * Removes the named Account Status Notification Handler.
193   *
194   * @param name
195   *          The name of the Account Status Notification Handler to
196   *          remove.
197   * @throws ManagedObjectNotFoundException
198   *           If the Account Status Notification Handler does not
199   *           exist.
200   * @throws OperationRejectedException
201   *           If the server refuses to remove the Account Status
202   *           Notification Handler due to some server-side constraint
203   *           which cannot be satisfied (for example, if it is
204   *           referenced by another managed object).
205   * @throws ConcurrentModificationException
206   *           If this Root has been removed from the server by
207   *           another client.
208   * @throws LdapException
209   *           If any other error occurs.
210   */
211  void removeAccountStatusNotificationHandler(String name)
212      throws ManagedObjectNotFoundException, OperationRejectedException,
213      ConcurrentModificationException, LdapException;
214
215
216
217  /**
218   * Gets the Administration Connector.
219   *
220   * @return Returns the Administration Connector.
221   * @throws DefinitionDecodingException
222   *           If the Administration Connector was found but its type
223   *           could not be determined.
224   * @throws ManagedObjectDecodingException
225   *           If the Administration Connector was found but one or
226   *           more of its properties could not be decoded.
227   * @throws ManagedObjectNotFoundException
228   *           If the Administration Connector could not be found on
229   *           the server.
230   * @throws ConcurrentModificationException
231   *           If this Root has been removed from the server by
232   *           another client.
233   * @throws LdapException
234   *           If any other error occurs.
235   */
236  AdministrationConnectorCfgClient getAdministrationConnector()
237      throws DefinitionDecodingException, ManagedObjectDecodingException,
238      ManagedObjectNotFoundException, ConcurrentModificationException,
239      LdapException;
240
241
242
243  /**
244   * Lists the Alert Handlers.
245   *
246   * @return Returns an array containing the names of the Alert
247   *         Handlers.
248   * @throws ConcurrentModificationException
249   *           If this Root has been removed from the server by
250   *           another client.
251   * @throws LdapException
252   *           If any other error occurs.
253   */
254  String[] listAlertHandlers() throws ConcurrentModificationException,
255      LdapException;
256
257
258
259  /**
260   * Gets the named Alert Handler.
261   *
262   * @param name
263   *           The name of the Alert Handler to retrieve.
264   * @return Returns the named Alert Handler.
265   * @throws DefinitionDecodingException
266   *           If the named Alert Handler was found but its type could
267   *           not be determined.
268   * @throws ManagedObjectDecodingException
269   *           If the named Alert Handler was found but one or more of
270   *           its properties could not be decoded.
271   * @throws ManagedObjectNotFoundException
272   *           If the named Alert Handler was not found on the server.
273   * @throws ConcurrentModificationException
274   *           If this Root has been removed from the server by
275   *           another client.
276   * @throws LdapException
277   *           If any other error occurs.
278   */
279  AlertHandlerCfgClient getAlertHandler(String name)
280      throws DefinitionDecodingException, ManagedObjectDecodingException,
281      ManagedObjectNotFoundException, ConcurrentModificationException,
282      LdapException;
283
284
285
286  /**
287   * Creates a new Alert Handler. The new Alert Handler will initially
288   * not contain any property values (including mandatory properties).
289   * Once the Alert Handler has been configured it can be added to the
290   * server using the {@link #commit()} method.
291   *
292   * @param <C>
293   *          The type of the Alert Handler being created.
294   * @param d
295   *          The definition of the Alert Handler to be created.
296   * @param name
297   *          The name of the new Alert Handler.
298   * @param exceptions
299   *          An optional collection in which to place any {@link
300   *          PropertyException}s that occurred whilst attempting to
301   *          determine the default values of the Alert Handler. This
302   *          argument can be <code>null<code>.
303   * @return Returns a new Alert Handler configuration instance.
304   * @throws IllegalManagedObjectNameException
305   *          If the name of the new Alert Handler is invalid.
306   */
307  <C extends AlertHandlerCfgClient> C createAlertHandler(
308      ManagedObjectDefinition<C, ? extends AlertHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
309
310
311
312  /**
313   * Removes the named Alert Handler.
314   *
315   * @param name
316   *          The name of the Alert Handler to remove.
317   * @throws ManagedObjectNotFoundException
318   *           If the Alert Handler does not exist.
319   * @throws OperationRejectedException
320   *           If the server refuses to remove the Alert Handler due
321   *           to some server-side constraint which cannot be satisfied
322   *           (for example, if it is referenced by another managed
323   *           object).
324   * @throws ConcurrentModificationException
325   *           If this Root has been removed from the server by
326   *           another client.
327   * @throws LdapException
328   *           If any other error occurs.
329   */
330  void removeAlertHandler(String name)
331      throws ManagedObjectNotFoundException, OperationRejectedException,
332      ConcurrentModificationException, LdapException;
333
334
335
336  /**
337   * Lists the Attribute Syntaxes.
338   *
339   * @return Returns an array containing the names of the Attribute
340   *         Syntaxes.
341   * @throws ConcurrentModificationException
342   *           If this Root has been removed from the server by
343   *           another client.
344   * @throws LdapException
345   *           If any other error occurs.
346   */
347  String[] listAttributeSyntaxes() throws ConcurrentModificationException,
348      LdapException;
349
350
351
352  /**
353   * Gets the named Attribute Syntax.
354   *
355   * @param name
356   *           The name of the Attribute Syntax to retrieve.
357   * @return Returns the named Attribute Syntax.
358   * @throws DefinitionDecodingException
359   *           If the named Attribute Syntax was found but its type
360   *           could not be determined.
361   * @throws ManagedObjectDecodingException
362   *           If the named Attribute Syntax was found but one or more
363   *           of its properties could not be decoded.
364   * @throws ManagedObjectNotFoundException
365   *           If the named Attribute Syntax was not found on the
366   *           server.
367   * @throws ConcurrentModificationException
368   *           If this Root has been removed from the server by
369   *           another client.
370   * @throws LdapException
371   *           If any other error occurs.
372   */
373  AttributeSyntaxCfgClient getAttributeSyntax(String name)
374      throws DefinitionDecodingException, ManagedObjectDecodingException,
375      ManagedObjectNotFoundException, ConcurrentModificationException,
376      LdapException;
377
378
379
380  /**
381   * Creates a new Attribute Syntax. The new Attribute Syntax will
382   * initially not contain any property values (including mandatory
383   * properties). Once the Attribute Syntax has been configured it can
384   * be added to the server using the {@link #commit()} method.
385   *
386   * @param <C>
387   *          The type of the Attribute Syntax being created.
388   * @param d
389   *          The definition of the Attribute Syntax to be created.
390   * @param name
391   *          The name of the new Attribute Syntax.
392   * @param exceptions
393   *          An optional collection in which to place any {@link
394   *          PropertyException}s that occurred whilst attempting to
395   *          determine the default values of the Attribute Syntax.
396   *          This argument can be <code>null<code>.
397   * @return Returns a new Attribute Syntax configuration instance.
398   * @throws IllegalManagedObjectNameException
399   *          If the name of the new Attribute Syntax is invalid.
400   */
401  <C extends AttributeSyntaxCfgClient> C createAttributeSyntax(
402      ManagedObjectDefinition<C, ? extends AttributeSyntaxCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
403
404
405
406  /**
407   * Removes the named Attribute Syntax.
408   *
409   * @param name
410   *          The name of the Attribute Syntax to remove.
411   * @throws ManagedObjectNotFoundException
412   *           If the Attribute Syntax does not exist.
413   * @throws OperationRejectedException
414   *           If the server refuses to remove the Attribute Syntax
415   *           due to some server-side constraint which cannot be
416   *           satisfied (for example, if it is referenced by another
417   *           managed object).
418   * @throws ConcurrentModificationException
419   *           If this Root has been removed from the server by
420   *           another client.
421   * @throws LdapException
422   *           If any other error occurs.
423   */
424  void removeAttributeSyntax(String name)
425      throws ManagedObjectNotFoundException, OperationRejectedException,
426      ConcurrentModificationException, LdapException;
427
428
429
430  /**
431   * Lists the Backends.
432   *
433   * @return Returns an array containing the names of the Backends.
434   * @throws ConcurrentModificationException
435   *           If this Root has been removed from the server by
436   *           another client.
437   * @throws LdapException
438   *           If any other error occurs.
439   */
440  String[] listBackends() throws ConcurrentModificationException,
441      LdapException;
442
443
444
445  /**
446   * Gets the named Backend.
447   *
448   * @param name
449   *           The name of the Backend to retrieve.
450   * @return Returns the named Backend.
451   * @throws DefinitionDecodingException
452   *           If the named Backend was found but its type could not
453   *           be determined.
454   * @throws ManagedObjectDecodingException
455   *           If the named Backend was found but one or more of its
456   *           properties could not be decoded.
457   * @throws ManagedObjectNotFoundException
458   *           If the named Backend was not found on the server.
459   * @throws ConcurrentModificationException
460   *           If this Root has been removed from the server by
461   *           another client.
462   * @throws LdapException
463   *           If any other error occurs.
464   */
465  BackendCfgClient getBackend(String name)
466      throws DefinitionDecodingException, ManagedObjectDecodingException,
467      ManagedObjectNotFoundException, ConcurrentModificationException,
468      LdapException;
469
470
471
472  /**
473   * Creates a new Backend. The new Backend will initially not contain
474   * any property values (including mandatory properties). Once the
475   * Backend has been configured it can be added to the server using
476   * the {@link #commit()} method.
477   *
478   * @param <C>
479   *          The type of the Backend being created.
480   * @param d
481   *          The definition of the Backend to be created.
482   * @param name
483   *          The name of the new Backend.
484   * @param exceptions
485   *          An optional collection in which to place any {@link
486   *          PropertyException}s that occurred whilst attempting to
487   *          determine the default values of the Backend. This
488   *          argument can be <code>null<code>.
489   * @return Returns a new Backend configuration instance.
490   * @throws IllegalManagedObjectNameException
491   *          If the name of the new Backend is invalid.
492   */
493  <C extends BackendCfgClient> C createBackend(
494      ManagedObjectDefinition<C, ? extends BackendCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
495
496
497
498  /**
499   * Removes the named Backend.
500   *
501   * @param name
502   *          The name of the Backend to remove.
503   * @throws ManagedObjectNotFoundException
504   *           If the Backend does not exist.
505   * @throws OperationRejectedException
506   *           If the server refuses to remove the Backend due to some
507   *           server-side constraint which cannot be satisfied (for
508   *           example, if it is referenced by another managed object).
509   * @throws ConcurrentModificationException
510   *           If this Root has been removed from the server by
511   *           another client.
512   * @throws LdapException
513   *           If any other error occurs.
514   */
515  void removeBackend(String name)
516      throws ManagedObjectNotFoundException, OperationRejectedException,
517      ConcurrentModificationException, LdapException;
518
519
520
521  /**
522   * Lists the Certificate Mappers.
523   *
524   * @return Returns an array containing the names of the Certificate
525   *         Mappers.
526   * @throws ConcurrentModificationException
527   *           If this Root has been removed from the server by
528   *           another client.
529   * @throws LdapException
530   *           If any other error occurs.
531   */
532  String[] listCertificateMappers() throws ConcurrentModificationException,
533      LdapException;
534
535
536
537  /**
538   * Gets the named Certificate Mapper.
539   *
540   * @param name
541   *           The name of the Certificate Mapper to retrieve.
542   * @return Returns the named Certificate Mapper.
543   * @throws DefinitionDecodingException
544   *           If the named Certificate Mapper was found but its type
545   *           could not be determined.
546   * @throws ManagedObjectDecodingException
547   *           If the named Certificate Mapper was found but one or
548   *           more of its properties could not be decoded.
549   * @throws ManagedObjectNotFoundException
550   *           If the named Certificate Mapper was not found on the
551   *           server.
552   * @throws ConcurrentModificationException
553   *           If this Root has been removed from the server by
554   *           another client.
555   * @throws LdapException
556   *           If any other error occurs.
557   */
558  CertificateMapperCfgClient getCertificateMapper(String name)
559      throws DefinitionDecodingException, ManagedObjectDecodingException,
560      ManagedObjectNotFoundException, ConcurrentModificationException,
561      LdapException;
562
563
564
565  /**
566   * Creates a new Certificate Mapper. The new Certificate Mapper will
567   * initially not contain any property values (including mandatory
568   * properties). Once the Certificate Mapper has been configured it
569   * can be added to the server using the {@link #commit()} method.
570   *
571   * @param <C>
572   *          The type of the Certificate Mapper being created.
573   * @param d
574   *          The definition of the Certificate Mapper to be created.
575   * @param name
576   *          The name of the new Certificate Mapper.
577   * @param exceptions
578   *          An optional collection in which to place any {@link
579   *          PropertyException}s that occurred whilst attempting to
580   *          determine the default values of the Certificate Mapper.
581   *          This argument can be <code>null<code>.
582   * @return Returns a new Certificate Mapper configuration instance.
583   * @throws IllegalManagedObjectNameException
584   *          If the name of the new Certificate Mapper is invalid.
585   */
586  <C extends CertificateMapperCfgClient> C createCertificateMapper(
587      ManagedObjectDefinition<C, ? extends CertificateMapperCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
588
589
590
591  /**
592   * Removes the named Certificate Mapper.
593   *
594   * @param name
595   *          The name of the Certificate Mapper to remove.
596   * @throws ManagedObjectNotFoundException
597   *           If the Certificate Mapper does not exist.
598   * @throws OperationRejectedException
599   *           If the server refuses to remove the Certificate Mapper
600   *           due to some server-side constraint which cannot be
601   *           satisfied (for example, if it is referenced by another
602   *           managed object).
603   * @throws ConcurrentModificationException
604   *           If this Root has been removed from the server by
605   *           another client.
606   * @throws LdapException
607   *           If any other error occurs.
608   */
609  void removeCertificateMapper(String name)
610      throws ManagedObjectNotFoundException, OperationRejectedException,
611      ConcurrentModificationException, LdapException;
612
613
614
615  /**
616   * Lists the Connection Handlers.
617   *
618   * @return Returns an array containing the names of the Connection
619   *         Handlers.
620   * @throws ConcurrentModificationException
621   *           If this Root has been removed from the server by
622   *           another client.
623   * @throws LdapException
624   *           If any other error occurs.
625   */
626  String[] listConnectionHandlers() throws ConcurrentModificationException,
627      LdapException;
628
629
630
631  /**
632   * Gets the named Connection Handler.
633   *
634   * @param name
635   *           The name of the Connection Handler to retrieve.
636   * @return Returns the named Connection Handler.
637   * @throws DefinitionDecodingException
638   *           If the named Connection Handler was found but its type
639   *           could not be determined.
640   * @throws ManagedObjectDecodingException
641   *           If the named Connection Handler was found but one or
642   *           more of its properties could not be decoded.
643   * @throws ManagedObjectNotFoundException
644   *           If the named Connection Handler was not found on the
645   *           server.
646   * @throws ConcurrentModificationException
647   *           If this Root has been removed from the server by
648   *           another client.
649   * @throws LdapException
650   *           If any other error occurs.
651   */
652  ConnectionHandlerCfgClient getConnectionHandler(String name)
653      throws DefinitionDecodingException, ManagedObjectDecodingException,
654      ManagedObjectNotFoundException, ConcurrentModificationException,
655      LdapException;
656
657
658
659  /**
660   * Creates a new Connection Handler. The new Connection Handler will
661   * initially not contain any property values (including mandatory
662   * properties). Once the Connection Handler has been configured it
663   * can be added to the server using the {@link #commit()} method.
664   *
665   * @param <C>
666   *          The type of the Connection Handler being created.
667   * @param d
668   *          The definition of the Connection Handler to be created.
669   * @param name
670   *          The name of the new Connection Handler.
671   * @param exceptions
672   *          An optional collection in which to place any {@link
673   *          PropertyException}s that occurred whilst attempting to
674   *          determine the default values of the Connection Handler.
675   *          This argument can be <code>null<code>.
676   * @return Returns a new Connection Handler configuration instance.
677   * @throws IllegalManagedObjectNameException
678   *          If the name of the new Connection Handler is invalid.
679   */
680  <C extends ConnectionHandlerCfgClient> C createConnectionHandler(
681      ManagedObjectDefinition<C, ? extends ConnectionHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
682
683
684
685  /**
686   * Removes the named Connection Handler.
687   *
688   * @param name
689   *          The name of the Connection Handler to remove.
690   * @throws ManagedObjectNotFoundException
691   *           If the Connection Handler does not exist.
692   * @throws OperationRejectedException
693   *           If the server refuses to remove the Connection Handler
694   *           due to some server-side constraint which cannot be
695   *           satisfied (for example, if it is referenced by another
696   *           managed object).
697   * @throws ConcurrentModificationException
698   *           If this Root has been removed from the server by
699   *           another client.
700   * @throws LdapException
701   *           If any other error occurs.
702   */
703  void removeConnectionHandler(String name)
704      throws ManagedObjectNotFoundException, OperationRejectedException,
705      ConcurrentModificationException, LdapException;
706
707
708
709  /**
710   * Gets the Crypto Manager.
711   *
712   * @return Returns the Crypto Manager.
713   * @throws DefinitionDecodingException
714   *           If the Crypto Manager was found but its type could not
715   *           be determined.
716   * @throws ManagedObjectDecodingException
717   *           If the Crypto Manager was found but one or more of its
718   *           properties could not be decoded.
719   * @throws ManagedObjectNotFoundException
720   *           If the Crypto Manager could not be found on the server.
721   * @throws ConcurrentModificationException
722   *           If this Root has been removed from the server by
723   *           another client.
724   * @throws LdapException
725   *           If any other error occurs.
726   */
727  CryptoManagerCfgClient getCryptoManager()
728      throws DefinitionDecodingException, ManagedObjectDecodingException,
729      ManagedObjectNotFoundException, ConcurrentModificationException,
730      LdapException;
731
732
733
734  /**
735   * Lists the Entry Caches.
736   *
737   * @return Returns an array containing the names of the Entry
738   *         Caches.
739   * @throws ConcurrentModificationException
740   *           If this Root has been removed from the server by
741   *           another client.
742   * @throws LdapException
743   *           If any other error occurs.
744   */
745  String[] listEntryCaches() throws ConcurrentModificationException,
746      LdapException;
747
748
749
750  /**
751   * Gets the named Entry Cache.
752   *
753   * @param name
754   *           The name of the Entry Cache to retrieve.
755   * @return Returns the named Entry Cache.
756   * @throws DefinitionDecodingException
757   *           If the named Entry Cache was found but its type could
758   *           not be determined.
759   * @throws ManagedObjectDecodingException
760   *           If the named Entry Cache was found but one or more of
761   *           its properties could not be decoded.
762   * @throws ManagedObjectNotFoundException
763   *           If the named Entry Cache was not found on the server.
764   * @throws ConcurrentModificationException
765   *           If this Root has been removed from the server by
766   *           another client.
767   * @throws LdapException
768   *           If any other error occurs.
769   */
770  EntryCacheCfgClient getEntryCache(String name)
771      throws DefinitionDecodingException, ManagedObjectDecodingException,
772      ManagedObjectNotFoundException, ConcurrentModificationException,
773      LdapException;
774
775
776
777  /**
778   * Creates a new Entry Cache. The new Entry Cache will initially not
779   * contain any property values (including mandatory properties). Once
780   * the Entry Cache has been configured it can be added to the server
781   * using the {@link #commit()} method.
782   *
783   * @param <C>
784   *          The type of the Entry Cache being created.
785   * @param d
786   *          The definition of the Entry Cache to be created.
787   * @param name
788   *          The name of the new Entry Cache.
789   * @param exceptions
790   *          An optional collection in which to place any {@link
791   *          PropertyException}s that occurred whilst attempting to
792   *          determine the default values of the Entry Cache. This
793   *          argument can be <code>null<code>.
794   * @return Returns a new Entry Cache configuration instance.
795   * @throws IllegalManagedObjectNameException
796   *          If the name of the new Entry Cache is invalid.
797   */
798  <C extends EntryCacheCfgClient> C createEntryCache(
799      ManagedObjectDefinition<C, ? extends EntryCacheCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
800
801
802
803  /**
804   * Removes the named Entry Cache.
805   *
806   * @param name
807   *          The name of the Entry Cache to remove.
808   * @throws ManagedObjectNotFoundException
809   *           If the Entry Cache does not exist.
810   * @throws OperationRejectedException
811   *           If the server refuses to remove the Entry Cache due to
812   *           some server-side constraint which cannot be satisfied
813   *           (for example, if it is referenced by another managed
814   *           object).
815   * @throws ConcurrentModificationException
816   *           If this Root has been removed from the server by
817   *           another client.
818   * @throws LdapException
819   *           If any other error occurs.
820   */
821  void removeEntryCache(String name)
822      throws ManagedObjectNotFoundException, OperationRejectedException,
823      ConcurrentModificationException, LdapException;
824
825
826
827  /**
828   * Lists the Extended Operation Handlers.
829   *
830   * @return Returns an array containing the names of the Extended
831   *         Operation Handlers.
832   * @throws ConcurrentModificationException
833   *           If this Root has been removed from the server by
834   *           another client.
835   * @throws LdapException
836   *           If any other error occurs.
837   */
838  String[] listExtendedOperationHandlers() throws ConcurrentModificationException,
839      LdapException;
840
841
842
843  /**
844   * Gets the named Extended Operation Handler.
845   *
846   * @param name
847   *           The name of the Extended Operation Handler to retrieve.
848   * @return Returns the named Extended Operation Handler.
849   * @throws DefinitionDecodingException
850   *           If the named Extended Operation Handler was found but
851   *           its type could not be determined.
852   * @throws ManagedObjectDecodingException
853   *           If the named Extended Operation Handler was found but
854   *           one or more of its properties could not be decoded.
855   * @throws ManagedObjectNotFoundException
856   *           If the named Extended Operation Handler was not found
857   *           on the server.
858   * @throws ConcurrentModificationException
859   *           If this Root has been removed from the server by
860   *           another client.
861   * @throws LdapException
862   *           If any other error occurs.
863   */
864  ExtendedOperationHandlerCfgClient getExtendedOperationHandler(String name)
865      throws DefinitionDecodingException, ManagedObjectDecodingException,
866      ManagedObjectNotFoundException, ConcurrentModificationException,
867      LdapException;
868
869
870
871  /**
872   * Creates a new Extended Operation Handler. The new Extended
873   * Operation Handler will initially not contain any property values
874   * (including mandatory properties). Once the Extended Operation
875   * Handler has been configured it can be added to the server using
876   * the {@link #commit()} method.
877   *
878   * @param <C>
879   *          The type of the Extended Operation Handler being
880   *          created.
881   * @param d
882   *          The definition of the Extended Operation Handler to be
883   *          created.
884   * @param name
885   *          The name of the new Extended Operation Handler.
886   * @param exceptions
887   *          An optional collection in which to place any {@link
888   *          PropertyException}s that occurred whilst attempting to
889   *          determine the default values of the Extended Operation
890   *          Handler. This argument can be <code>null<code>.
891   * @return Returns a new Extended Operation Handler configuration
892   *         instance.
893   * @throws IllegalManagedObjectNameException
894   *          If the name of the new Extended Operation Handler is
895   *          invalid.
896   */
897  <C extends ExtendedOperationHandlerCfgClient> C createExtendedOperationHandler(
898      ManagedObjectDefinition<C, ? extends ExtendedOperationHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
899
900
901
902  /**
903   * Removes the named Extended Operation Handler.
904   *
905   * @param name
906   *          The name of the Extended Operation Handler to remove.
907   * @throws ManagedObjectNotFoundException
908   *           If the Extended Operation Handler does not exist.
909   * @throws OperationRejectedException
910   *           If the server refuses to remove the Extended Operation
911   *           Handler due to some server-side constraint which cannot
912   *           be satisfied (for example, if it is referenced by
913   *           another managed object).
914   * @throws ConcurrentModificationException
915   *           If this Root has been removed from the server by
916   *           another client.
917   * @throws LdapException
918   *           If any other error occurs.
919   */
920  void removeExtendedOperationHandler(String name)
921      throws ManagedObjectNotFoundException, OperationRejectedException,
922      ConcurrentModificationException, LdapException;
923
924
925
926  /**
927   * Gets the Global Configuration.
928   *
929   * @return Returns the Global Configuration.
930   * @throws DefinitionDecodingException
931   *           If the Global Configuration was found but its type
932   *           could not be determined.
933   * @throws ManagedObjectDecodingException
934   *           If the Global Configuration was found but one or more
935   *           of its properties could not be decoded.
936   * @throws ManagedObjectNotFoundException
937   *           If the Global Configuration could not be found on the
938   *           server.
939   * @throws ConcurrentModificationException
940   *           If this Root has been removed from the server by
941   *           another client.
942   * @throws LdapException
943   *           If any other error occurs.
944   */
945  GlobalCfgClient getGlobalConfiguration()
946      throws DefinitionDecodingException, ManagedObjectDecodingException,
947      ManagedObjectNotFoundException, ConcurrentModificationException,
948      LdapException;
949
950
951
952  /**
953   * Lists the Group Implementations.
954   *
955   * @return Returns an array containing the names of the Group
956   *         Implementations.
957   * @throws ConcurrentModificationException
958   *           If this Root has been removed from the server by
959   *           another client.
960   * @throws LdapException
961   *           If any other error occurs.
962   */
963  String[] listGroupImplementations() throws ConcurrentModificationException,
964      LdapException;
965
966
967
968  /**
969   * Gets the named Group Implementation.
970   *
971   * @param name
972   *           The name of the Group Implementation to retrieve.
973   * @return Returns the named Group Implementation.
974   * @throws DefinitionDecodingException
975   *           If the named Group Implementation was found but its
976   *           type could not be determined.
977   * @throws ManagedObjectDecodingException
978   *           If the named Group Implementation was found but one or
979   *           more of its properties could not be decoded.
980   * @throws ManagedObjectNotFoundException
981   *           If the named Group Implementation was not found on the
982   *           server.
983   * @throws ConcurrentModificationException
984   *           If this Root has been removed from the server by
985   *           another client.
986   * @throws LdapException
987   *           If any other error occurs.
988   */
989  GroupImplementationCfgClient getGroupImplementation(String name)
990      throws DefinitionDecodingException, ManagedObjectDecodingException,
991      ManagedObjectNotFoundException, ConcurrentModificationException,
992      LdapException;
993
994
995
996  /**
997   * Creates a new Group Implementation. The new Group Implementation
998   * will initially not contain any property values (including
999   * mandatory properties). Once the Group Implementation has been
1000   * configured it can be added to the server using the {@link
1001   * #commit()} method.
1002   *
1003   * @param <C>
1004   *          The type of the Group Implementation being created.
1005   * @param d
1006   *          The definition of the Group Implementation to be
1007   *          created.
1008   * @param name
1009   *          The name of the new Group Implementation.
1010   * @param exceptions
1011   *          An optional collection in which to place any {@link
1012   *          PropertyException}s that occurred whilst attempting to
1013   *          determine the default values of the Group Implementation.
1014   *          This argument can be <code>null<code>.
1015   * @return Returns a new Group Implementation configuration
1016   *         instance.
1017   * @throws IllegalManagedObjectNameException
1018   *          If the name of the new Group Implementation is invalid.
1019   */
1020  <C extends GroupImplementationCfgClient> C createGroupImplementation(
1021      ManagedObjectDefinition<C, ? extends GroupImplementationCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1022
1023
1024
1025  /**
1026   * Removes the named Group Implementation.
1027   *
1028   * @param name
1029   *          The name of the Group Implementation to remove.
1030   * @throws ManagedObjectNotFoundException
1031   *           If the Group Implementation does not exist.
1032   * @throws OperationRejectedException
1033   *           If the server refuses to remove the Group
1034   *           Implementation due to some server-side constraint which
1035   *           cannot be satisfied (for example, if it is referenced by
1036   *           another managed object).
1037   * @throws ConcurrentModificationException
1038   *           If this Root has been removed from the server by
1039   *           another client.
1040   * @throws LdapException
1041   *           If any other error occurs.
1042   */
1043  void removeGroupImplementation(String name)
1044      throws ManagedObjectNotFoundException, OperationRejectedException,
1045      ConcurrentModificationException, LdapException;
1046
1047
1048
1049  /**
1050   * Lists the Identity Mappers.
1051   *
1052   * @return Returns an array containing the names of the Identity
1053   *         Mappers.
1054   * @throws ConcurrentModificationException
1055   *           If this Root has been removed from the server by
1056   *           another client.
1057   * @throws LdapException
1058   *           If any other error occurs.
1059   */
1060  String[] listIdentityMappers() throws ConcurrentModificationException,
1061      LdapException;
1062
1063
1064
1065  /**
1066   * Gets the named Identity Mapper.
1067   *
1068   * @param name
1069   *           The name of the Identity Mapper to retrieve.
1070   * @return Returns the named Identity Mapper.
1071   * @throws DefinitionDecodingException
1072   *           If the named Identity Mapper was found but its type
1073   *           could not be determined.
1074   * @throws ManagedObjectDecodingException
1075   *           If the named Identity Mapper was found but one or more
1076   *           of its properties could not be decoded.
1077   * @throws ManagedObjectNotFoundException
1078   *           If the named Identity Mapper was not found on the
1079   *           server.
1080   * @throws ConcurrentModificationException
1081   *           If this Root has been removed from the server by
1082   *           another client.
1083   * @throws LdapException
1084   *           If any other error occurs.
1085   */
1086  IdentityMapperCfgClient getIdentityMapper(String name)
1087      throws DefinitionDecodingException, ManagedObjectDecodingException,
1088      ManagedObjectNotFoundException, ConcurrentModificationException,
1089      LdapException;
1090
1091
1092
1093  /**
1094   * Creates a new Identity Mapper. The new Identity Mapper will
1095   * initially not contain any property values (including mandatory
1096   * properties). Once the Identity Mapper has been configured it can
1097   * be added to the server using the {@link #commit()} method.
1098   *
1099   * @param <C>
1100   *          The type of the Identity Mapper being created.
1101   * @param d
1102   *          The definition of the Identity Mapper to be created.
1103   * @param name
1104   *          The name of the new Identity Mapper.
1105   * @param exceptions
1106   *          An optional collection in which to place any {@link
1107   *          PropertyException}s that occurred whilst attempting to
1108   *          determine the default values of the Identity Mapper. This
1109   *          argument can be <code>null<code>.
1110   * @return Returns a new Identity Mapper configuration instance.
1111   * @throws IllegalManagedObjectNameException
1112   *          If the name of the new Identity Mapper is invalid.
1113   */
1114  <C extends IdentityMapperCfgClient> C createIdentityMapper(
1115      ManagedObjectDefinition<C, ? extends IdentityMapperCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1116
1117
1118
1119  /**
1120   * Removes the named Identity Mapper.
1121   *
1122   * @param name
1123   *          The name of the Identity Mapper to remove.
1124   * @throws ManagedObjectNotFoundException
1125   *           If the Identity Mapper does not exist.
1126   * @throws OperationRejectedException
1127   *           If the server refuses to remove the Identity Mapper due
1128   *           to some server-side constraint which cannot be satisfied
1129   *           (for example, if it is referenced by another managed
1130   *           object).
1131   * @throws ConcurrentModificationException
1132   *           If this Root has been removed from the server by
1133   *           another client.
1134   * @throws LdapException
1135   *           If any other error occurs.
1136   */
1137  void removeIdentityMapper(String name)
1138      throws ManagedObjectNotFoundException, OperationRejectedException,
1139      ConcurrentModificationException, LdapException;
1140
1141
1142
1143  /**
1144   * Lists the Key Manager Providers.
1145   *
1146   * @return Returns an array containing the names of the Key Manager
1147   *         Providers.
1148   * @throws ConcurrentModificationException
1149   *           If this Root has been removed from the server by
1150   *           another client.
1151   * @throws LdapException
1152   *           If any other error occurs.
1153   */
1154  String[] listKeyManagerProviders() throws ConcurrentModificationException,
1155      LdapException;
1156
1157
1158
1159  /**
1160   * Gets the named Key Manager Provider.
1161   *
1162   * @param name
1163   *           The name of the Key Manager Provider to retrieve.
1164   * @return Returns the named Key Manager Provider.
1165   * @throws DefinitionDecodingException
1166   *           If the named Key Manager Provider was found but its
1167   *           type could not be determined.
1168   * @throws ManagedObjectDecodingException
1169   *           If the named Key Manager Provider was found but one or
1170   *           more of its properties could not be decoded.
1171   * @throws ManagedObjectNotFoundException
1172   *           If the named Key Manager Provider was not found on the
1173   *           server.
1174   * @throws ConcurrentModificationException
1175   *           If this Root has been removed from the server by
1176   *           another client.
1177   * @throws LdapException
1178   *           If any other error occurs.
1179   */
1180  KeyManagerProviderCfgClient getKeyManagerProvider(String name)
1181      throws DefinitionDecodingException, ManagedObjectDecodingException,
1182      ManagedObjectNotFoundException, ConcurrentModificationException,
1183      LdapException;
1184
1185
1186
1187  /**
1188   * Creates a new Key Manager Provider. The new Key Manager Provider
1189   * will initially not contain any property values (including
1190   * mandatory properties). Once the Key Manager Provider has been
1191   * configured it can be added to the server using the {@link
1192   * #commit()} method.
1193   *
1194   * @param <C>
1195   *          The type of the Key Manager Provider being created.
1196   * @param d
1197   *          The definition of the Key Manager Provider to be
1198   *          created.
1199   * @param name
1200   *          The name of the new Key Manager Provider.
1201   * @param exceptions
1202   *          An optional collection in which to place any {@link
1203   *          PropertyException}s that occurred whilst attempting to
1204   *          determine the default values of the Key Manager Provider.
1205   *          This argument can be <code>null<code>.
1206   * @return Returns a new Key Manager Provider configuration
1207   *         instance.
1208   * @throws IllegalManagedObjectNameException
1209   *          If the name of the new Key Manager Provider is invalid.
1210   */
1211  <C extends KeyManagerProviderCfgClient> C createKeyManagerProvider(
1212      ManagedObjectDefinition<C, ? extends KeyManagerProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1213
1214
1215
1216  /**
1217   * Removes the named Key Manager Provider.
1218   *
1219   * @param name
1220   *          The name of the Key Manager Provider to remove.
1221   * @throws ManagedObjectNotFoundException
1222   *           If the Key Manager Provider does not exist.
1223   * @throws OperationRejectedException
1224   *           If the server refuses to remove the Key Manager
1225   *           Provider due to some server-side constraint which cannot
1226   *           be satisfied (for example, if it is referenced by
1227   *           another managed object).
1228   * @throws ConcurrentModificationException
1229   *           If this Root has been removed from the server by
1230   *           another client.
1231   * @throws LdapException
1232   *           If any other error occurs.
1233   */
1234  void removeKeyManagerProvider(String name)
1235      throws ManagedObjectNotFoundException, OperationRejectedException,
1236      ConcurrentModificationException, LdapException;
1237
1238
1239
1240  /**
1241   * Lists the Log Publishers.
1242   *
1243   * @return Returns an array containing the names of the Log
1244   *         Publishers.
1245   * @throws ConcurrentModificationException
1246   *           If this Root has been removed from the server by
1247   *           another client.
1248   * @throws LdapException
1249   *           If any other error occurs.
1250   */
1251  String[] listLogPublishers() throws ConcurrentModificationException,
1252      LdapException;
1253
1254
1255
1256  /**
1257   * Gets the named Log Publisher.
1258   *
1259   * @param name
1260   *           The name of the Log Publisher to retrieve.
1261   * @return Returns the named Log Publisher.
1262   * @throws DefinitionDecodingException
1263   *           If the named Log Publisher was found but its type could
1264   *           not be determined.
1265   * @throws ManagedObjectDecodingException
1266   *           If the named Log Publisher was found but one or more of
1267   *           its properties could not be decoded.
1268   * @throws ManagedObjectNotFoundException
1269   *           If the named Log Publisher was not found on the server.
1270   * @throws ConcurrentModificationException
1271   *           If this Root has been removed from the server by
1272   *           another client.
1273   * @throws LdapException
1274   *           If any other error occurs.
1275   */
1276  LogPublisherCfgClient getLogPublisher(String name)
1277      throws DefinitionDecodingException, ManagedObjectDecodingException,
1278      ManagedObjectNotFoundException, ConcurrentModificationException,
1279      LdapException;
1280
1281
1282
1283  /**
1284   * Creates a new Log Publisher. The new Log Publisher will initially
1285   * not contain any property values (including mandatory properties).
1286   * Once the Log Publisher has been configured it can be added to the
1287   * server using the {@link #commit()} method.
1288   *
1289   * @param <C>
1290   *          The type of the Log Publisher being created.
1291   * @param d
1292   *          The definition of the Log Publisher to be created.
1293   * @param name
1294   *          The name of the new Log Publisher.
1295   * @param exceptions
1296   *          An optional collection in which to place any {@link
1297   *          PropertyException}s that occurred whilst attempting to
1298   *          determine the default values of the Log Publisher. This
1299   *          argument can be <code>null<code>.
1300   * @return Returns a new Log Publisher configuration instance.
1301   * @throws IllegalManagedObjectNameException
1302   *          If the name of the new Log Publisher is invalid.
1303   */
1304  <C extends LogPublisherCfgClient> C createLogPublisher(
1305      ManagedObjectDefinition<C, ? extends LogPublisherCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1306
1307
1308
1309  /**
1310   * Removes the named Log Publisher.
1311   *
1312   * @param name
1313   *          The name of the Log Publisher to remove.
1314   * @throws ManagedObjectNotFoundException
1315   *           If the Log Publisher does not exist.
1316   * @throws OperationRejectedException
1317   *           If the server refuses to remove the Log Publisher due
1318   *           to some server-side constraint which cannot be satisfied
1319   *           (for example, if it is referenced by another managed
1320   *           object).
1321   * @throws ConcurrentModificationException
1322   *           If this Root has been removed from the server by
1323   *           another client.
1324   * @throws LdapException
1325   *           If any other error occurs.
1326   */
1327  void removeLogPublisher(String name)
1328      throws ManagedObjectNotFoundException, OperationRejectedException,
1329      ConcurrentModificationException, LdapException;
1330
1331
1332
1333  /**
1334   * Lists the Log Retention Policies.
1335   *
1336   * @return Returns an array containing the names of the Log
1337   *         Retention Policies.
1338   * @throws ConcurrentModificationException
1339   *           If this Root has been removed from the server by
1340   *           another client.
1341   * @throws LdapException
1342   *           If any other error occurs.
1343   */
1344  String[] listLogRetentionPolicies() throws ConcurrentModificationException,
1345      LdapException;
1346
1347
1348
1349  /**
1350   * Gets the named Log Retention Policy.
1351   *
1352   * @param name
1353   *           The name of the Log Retention Policy to retrieve.
1354   * @return Returns the named Log Retention Policy.
1355   * @throws DefinitionDecodingException
1356   *           If the named Log Retention Policy was found but its
1357   *           type could not be determined.
1358   * @throws ManagedObjectDecodingException
1359   *           If the named Log Retention Policy was found but one or
1360   *           more of its properties could not be decoded.
1361   * @throws ManagedObjectNotFoundException
1362   *           If the named Log Retention Policy was not found on the
1363   *           server.
1364   * @throws ConcurrentModificationException
1365   *           If this Root has been removed from the server by
1366   *           another client.
1367   * @throws LdapException
1368   *           If any other error occurs.
1369   */
1370  LogRetentionPolicyCfgClient getLogRetentionPolicy(String name)
1371      throws DefinitionDecodingException, ManagedObjectDecodingException,
1372      ManagedObjectNotFoundException, ConcurrentModificationException,
1373      LdapException;
1374
1375
1376
1377  /**
1378   * Creates a new Log Retention Policy. The new Log Retention Policy
1379   * will initially not contain any property values (including
1380   * mandatory properties). Once the Log Retention Policy has been
1381   * configured it can be added to the server using the {@link
1382   * #commit()} method.
1383   *
1384   * @param <C>
1385   *          The type of the Log Retention Policy being created.
1386   * @param d
1387   *          The definition of the Log Retention Policy to be
1388   *          created.
1389   * @param name
1390   *          The name of the new Log Retention Policy.
1391   * @param exceptions
1392   *          An optional collection in which to place any {@link
1393   *          PropertyException}s that occurred whilst attempting to
1394   *          determine the default values of the Log Retention Policy.
1395   *          This argument can be <code>null<code>.
1396   * @return Returns a new Log Retention Policy configuration
1397   *         instance.
1398   * @throws IllegalManagedObjectNameException
1399   *          If the name of the new Log Retention Policy is invalid.
1400   */
1401  <C extends LogRetentionPolicyCfgClient> C createLogRetentionPolicy(
1402      ManagedObjectDefinition<C, ? extends LogRetentionPolicyCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1403
1404
1405
1406  /**
1407   * Removes the named Log Retention Policy.
1408   *
1409   * @param name
1410   *          The name of the Log Retention Policy to remove.
1411   * @throws ManagedObjectNotFoundException
1412   *           If the Log Retention Policy does not exist.
1413   * @throws OperationRejectedException
1414   *           If the server refuses to remove the Log Retention
1415   *           Policy due to some server-side constraint which cannot
1416   *           be satisfied (for example, if it is referenced by
1417   *           another managed object).
1418   * @throws ConcurrentModificationException
1419   *           If this Root has been removed from the server by
1420   *           another client.
1421   * @throws LdapException
1422   *           If any other error occurs.
1423   */
1424  void removeLogRetentionPolicy(String name)
1425      throws ManagedObjectNotFoundException, OperationRejectedException,
1426      ConcurrentModificationException, LdapException;
1427
1428
1429
1430  /**
1431   * Lists the Log Rotation Policies.
1432   *
1433   * @return Returns an array containing the names of the Log Rotation
1434   *         Policies.
1435   * @throws ConcurrentModificationException
1436   *           If this Root has been removed from the server by
1437   *           another client.
1438   * @throws LdapException
1439   *           If any other error occurs.
1440   */
1441  String[] listLogRotationPolicies() throws ConcurrentModificationException,
1442      LdapException;
1443
1444
1445
1446  /**
1447   * Gets the named Log Rotation Policy.
1448   *
1449   * @param name
1450   *           The name of the Log Rotation Policy to retrieve.
1451   * @return Returns the named Log Rotation Policy.
1452   * @throws DefinitionDecodingException
1453   *           If the named Log Rotation Policy was found but its type
1454   *           could not be determined.
1455   * @throws ManagedObjectDecodingException
1456   *           If the named Log Rotation Policy was found but one or
1457   *           more of its properties could not be decoded.
1458   * @throws ManagedObjectNotFoundException
1459   *           If the named Log Rotation Policy was not found on the
1460   *           server.
1461   * @throws ConcurrentModificationException
1462   *           If this Root has been removed from the server by
1463   *           another client.
1464   * @throws LdapException
1465   *           If any other error occurs.
1466   */
1467  LogRotationPolicyCfgClient getLogRotationPolicy(String name)
1468      throws DefinitionDecodingException, ManagedObjectDecodingException,
1469      ManagedObjectNotFoundException, ConcurrentModificationException,
1470      LdapException;
1471
1472
1473
1474  /**
1475   * Creates a new Log Rotation Policy. The new Log Rotation Policy
1476   * will initially not contain any property values (including
1477   * mandatory properties). Once the Log Rotation Policy has been
1478   * configured it can be added to the server using the {@link
1479   * #commit()} method.
1480   *
1481   * @param <C>
1482   *          The type of the Log Rotation Policy being created.
1483   * @param d
1484   *          The definition of the Log Rotation Policy to be created.
1485   * @param name
1486   *          The name of the new Log Rotation Policy.
1487   * @param exceptions
1488   *          An optional collection in which to place any {@link
1489   *          PropertyException}s that occurred whilst attempting to
1490   *          determine the default values of the Log Rotation Policy.
1491   *          This argument can be <code>null<code>.
1492   * @return Returns a new Log Rotation Policy configuration instance.
1493   * @throws IllegalManagedObjectNameException
1494   *          If the name of the new Log Rotation Policy is invalid.
1495   */
1496  <C extends LogRotationPolicyCfgClient> C createLogRotationPolicy(
1497      ManagedObjectDefinition<C, ? extends LogRotationPolicyCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1498
1499
1500
1501  /**
1502   * Removes the named Log Rotation Policy.
1503   *
1504   * @param name
1505   *          The name of the Log Rotation Policy to remove.
1506   * @throws ManagedObjectNotFoundException
1507   *           If the Log Rotation Policy does not exist.
1508   * @throws OperationRejectedException
1509   *           If the server refuses to remove the Log Rotation Policy
1510   *           due to some server-side constraint which cannot be
1511   *           satisfied (for example, if it is referenced by another
1512   *           managed object).
1513   * @throws ConcurrentModificationException
1514   *           If this Root has been removed from the server by
1515   *           another client.
1516   * @throws LdapException
1517   *           If any other error occurs.
1518   */
1519  void removeLogRotationPolicy(String name)
1520      throws ManagedObjectNotFoundException, OperationRejectedException,
1521      ConcurrentModificationException, LdapException;
1522
1523
1524
1525  /**
1526   * Lists the Matching Rules.
1527   *
1528   * @return Returns an array containing the names of the Matching
1529   *         Rules.
1530   * @throws ConcurrentModificationException
1531   *           If this Root has been removed from the server by
1532   *           another client.
1533   * @throws LdapException
1534   *           If any other error occurs.
1535   */
1536  String[] listMatchingRules() throws ConcurrentModificationException,
1537      LdapException;
1538
1539
1540
1541  /**
1542   * Gets the named Matching Rule.
1543   *
1544   * @param name
1545   *           The name of the Matching Rule to retrieve.
1546   * @return Returns the named Matching Rule.
1547   * @throws DefinitionDecodingException
1548   *           If the named Matching Rule was found but its type could
1549   *           not be determined.
1550   * @throws ManagedObjectDecodingException
1551   *           If the named Matching Rule was found but one or more of
1552   *           its properties could not be decoded.
1553   * @throws ManagedObjectNotFoundException
1554   *           If the named Matching Rule was not found on the server.
1555   * @throws ConcurrentModificationException
1556   *           If this Root has been removed from the server by
1557   *           another client.
1558   * @throws LdapException
1559   *           If any other error occurs.
1560   */
1561  MatchingRuleCfgClient getMatchingRule(String name)
1562      throws DefinitionDecodingException, ManagedObjectDecodingException,
1563      ManagedObjectNotFoundException, ConcurrentModificationException,
1564      LdapException;
1565
1566
1567
1568  /**
1569   * Creates a new Matching Rule. The new Matching Rule will initially
1570   * not contain any property values (including mandatory properties).
1571   * Once the Matching Rule has been configured it can be added to the
1572   * server using the {@link #commit()} method.
1573   *
1574   * @param <C>
1575   *          The type of the Matching Rule being created.
1576   * @param d
1577   *          The definition of the Matching Rule to be created.
1578   * @param name
1579   *          The name of the new Matching Rule.
1580   * @param exceptions
1581   *          An optional collection in which to place any {@link
1582   *          PropertyException}s that occurred whilst attempting to
1583   *          determine the default values of the Matching Rule. This
1584   *          argument can be <code>null<code>.
1585   * @return Returns a new Matching Rule configuration instance.
1586   * @throws IllegalManagedObjectNameException
1587   *          If the name of the new Matching Rule is invalid.
1588   */
1589  <C extends MatchingRuleCfgClient> C createMatchingRule(
1590      ManagedObjectDefinition<C, ? extends MatchingRuleCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1591
1592
1593
1594  /**
1595   * Removes the named Matching Rule.
1596   *
1597   * @param name
1598   *          The name of the Matching Rule to remove.
1599   * @throws ManagedObjectNotFoundException
1600   *           If the Matching Rule does not exist.
1601   * @throws OperationRejectedException
1602   *           If the server refuses to remove the Matching Rule due
1603   *           to some server-side constraint which cannot be satisfied
1604   *           (for example, if it is referenced by another managed
1605   *           object).
1606   * @throws ConcurrentModificationException
1607   *           If this Root has been removed from the server by
1608   *           another client.
1609   * @throws LdapException
1610   *           If any other error occurs.
1611   */
1612  void removeMatchingRule(String name)
1613      throws ManagedObjectNotFoundException, OperationRejectedException,
1614      ConcurrentModificationException, LdapException;
1615
1616
1617
1618  /**
1619   * Lists the Monitor Providers.
1620   *
1621   * @return Returns an array containing the names of the Monitor
1622   *         Providers.
1623   * @throws ConcurrentModificationException
1624   *           If this Root has been removed from the server by
1625   *           another client.
1626   * @throws LdapException
1627   *           If any other error occurs.
1628   */
1629  String[] listMonitorProviders() throws ConcurrentModificationException,
1630      LdapException;
1631
1632
1633
1634  /**
1635   * Gets the named Monitor Provider.
1636   *
1637   * @param name
1638   *           The name of the Monitor Provider to retrieve.
1639   * @return Returns the named Monitor Provider.
1640   * @throws DefinitionDecodingException
1641   *           If the named Monitor Provider was found but its type
1642   *           could not be determined.
1643   * @throws ManagedObjectDecodingException
1644   *           If the named Monitor Provider was found but one or more
1645   *           of its properties could not be decoded.
1646   * @throws ManagedObjectNotFoundException
1647   *           If the named Monitor Provider was not found on the
1648   *           server.
1649   * @throws ConcurrentModificationException
1650   *           If this Root has been removed from the server by
1651   *           another client.
1652   * @throws LdapException
1653   *           If any other error occurs.
1654   */
1655  MonitorProviderCfgClient getMonitorProvider(String name)
1656      throws DefinitionDecodingException, ManagedObjectDecodingException,
1657      ManagedObjectNotFoundException, ConcurrentModificationException,
1658      LdapException;
1659
1660
1661
1662  /**
1663   * Creates a new Monitor Provider. The new Monitor Provider will
1664   * initially not contain any property values (including mandatory
1665   * properties). Once the Monitor Provider has been configured it can
1666   * be added to the server using the {@link #commit()} method.
1667   *
1668   * @param <C>
1669   *          The type of the Monitor Provider being created.
1670   * @param d
1671   *          The definition of the Monitor Provider to be created.
1672   * @param name
1673   *          The name of the new Monitor Provider.
1674   * @param exceptions
1675   *          An optional collection in which to place any {@link
1676   *          PropertyException}s that occurred whilst attempting to
1677   *          determine the default values of the Monitor Provider.
1678   *          This argument can be <code>null<code>.
1679   * @return Returns a new Monitor Provider configuration instance.
1680   * @throws IllegalManagedObjectNameException
1681   *          If the name of the new Monitor Provider is invalid.
1682   */
1683  <C extends MonitorProviderCfgClient> C createMonitorProvider(
1684      ManagedObjectDefinition<C, ? extends MonitorProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1685
1686
1687
1688  /**
1689   * Removes the named Monitor Provider.
1690   *
1691   * @param name
1692   *          The name of the Monitor Provider to remove.
1693   * @throws ManagedObjectNotFoundException
1694   *           If the Monitor Provider does not exist.
1695   * @throws OperationRejectedException
1696   *           If the server refuses to remove the Monitor Provider
1697   *           due to some server-side constraint which cannot be
1698   *           satisfied (for example, if it is referenced by another
1699   *           managed object).
1700   * @throws ConcurrentModificationException
1701   *           If this Root has been removed from the server by
1702   *           another client.
1703   * @throws LdapException
1704   *           If any other error occurs.
1705   */
1706  void removeMonitorProvider(String name)
1707      throws ManagedObjectNotFoundException, OperationRejectedException,
1708      ConcurrentModificationException, LdapException;
1709
1710
1711
1712  /**
1713   * Lists the Password Generators.
1714   *
1715   * @return Returns an array containing the names of the Password
1716   *         Generators.
1717   * @throws ConcurrentModificationException
1718   *           If this Root has been removed from the server by
1719   *           another client.
1720   * @throws LdapException
1721   *           If any other error occurs.
1722   */
1723  String[] listPasswordGenerators() throws ConcurrentModificationException,
1724      LdapException;
1725
1726
1727
1728  /**
1729   * Gets the named Password Generator.
1730   *
1731   * @param name
1732   *           The name of the Password Generator to retrieve.
1733   * @return Returns the named Password Generator.
1734   * @throws DefinitionDecodingException
1735   *           If the named Password Generator was found but its type
1736   *           could not be determined.
1737   * @throws ManagedObjectDecodingException
1738   *           If the named Password Generator was found but one or
1739   *           more of its properties could not be decoded.
1740   * @throws ManagedObjectNotFoundException
1741   *           If the named Password Generator was not found on the
1742   *           server.
1743   * @throws ConcurrentModificationException
1744   *           If this Root has been removed from the server by
1745   *           another client.
1746   * @throws LdapException
1747   *           If any other error occurs.
1748   */
1749  PasswordGeneratorCfgClient getPasswordGenerator(String name)
1750      throws DefinitionDecodingException, ManagedObjectDecodingException,
1751      ManagedObjectNotFoundException, ConcurrentModificationException,
1752      LdapException;
1753
1754
1755
1756  /**
1757   * Creates a new Password Generator. The new Password Generator will
1758   * initially not contain any property values (including mandatory
1759   * properties). Once the Password Generator has been configured it
1760   * can be added to the server using the {@link #commit()} method.
1761   *
1762   * @param <C>
1763   *          The type of the Password Generator being created.
1764   * @param d
1765   *          The definition of the Password Generator to be created.
1766   * @param name
1767   *          The name of the new Password Generator.
1768   * @param exceptions
1769   *          An optional collection in which to place any {@link
1770   *          PropertyException}s that occurred whilst attempting to
1771   *          determine the default values of the Password Generator.
1772   *          This argument can be <code>null<code>.
1773   * @return Returns a new Password Generator configuration instance.
1774   * @throws IllegalManagedObjectNameException
1775   *          If the name of the new Password Generator is invalid.
1776   */
1777  <C extends PasswordGeneratorCfgClient> C createPasswordGenerator(
1778      ManagedObjectDefinition<C, ? extends PasswordGeneratorCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1779
1780
1781
1782  /**
1783   * Removes the named Password Generator.
1784   *
1785   * @param name
1786   *          The name of the Password Generator to remove.
1787   * @throws ManagedObjectNotFoundException
1788   *           If the Password Generator does not exist.
1789   * @throws OperationRejectedException
1790   *           If the server refuses to remove the Password Generator
1791   *           due to some server-side constraint which cannot be
1792   *           satisfied (for example, if it is referenced by another
1793   *           managed object).
1794   * @throws ConcurrentModificationException
1795   *           If this Root has been removed from the server by
1796   *           another client.
1797   * @throws LdapException
1798   *           If any other error occurs.
1799   */
1800  void removePasswordGenerator(String name)
1801      throws ManagedObjectNotFoundException, OperationRejectedException,
1802      ConcurrentModificationException, LdapException;
1803
1804
1805
1806  /**
1807   * Lists the Password Policies.
1808   *
1809   * @return Returns an array containing the names of the Password
1810   *         Policies.
1811   * @throws ConcurrentModificationException
1812   *           If this Root has been removed from the server by
1813   *           another client.
1814   * @throws LdapException
1815   *           If any other error occurs.
1816   */
1817  String[] listPasswordPolicies() throws ConcurrentModificationException,
1818      LdapException;
1819
1820
1821
1822  /**
1823   * Gets the named Password Policy.
1824   *
1825   * @param name
1826   *           The name of the Password Policy to retrieve.
1827   * @return Returns the named Password Policy.
1828   * @throws DefinitionDecodingException
1829   *           If the named Password Policy was found but its type
1830   *           could not be determined.
1831   * @throws ManagedObjectDecodingException
1832   *           If the named Password Policy was found but one or more
1833   *           of its properties could not be decoded.
1834   * @throws ManagedObjectNotFoundException
1835   *           If the named Password Policy was not found on the
1836   *           server.
1837   * @throws ConcurrentModificationException
1838   *           If this Root has been removed from the server by
1839   *           another client.
1840   * @throws LdapException
1841   *           If any other error occurs.
1842   */
1843  AuthenticationPolicyCfgClient getPasswordPolicy(String name)
1844      throws DefinitionDecodingException, ManagedObjectDecodingException,
1845      ManagedObjectNotFoundException, ConcurrentModificationException,
1846      LdapException;
1847
1848
1849
1850  /**
1851   * Creates a new Password Policy. The new Password Policy will
1852   * initially not contain any property values (including mandatory
1853   * properties). Once the Password Policy has been configured it can
1854   * be added to the server using the {@link #commit()} method.
1855   *
1856   * @param <C>
1857   *          The type of the Password Policy being created.
1858   * @param d
1859   *          The definition of the Password Policy to be created.
1860   * @param name
1861   *          The name of the new Password Policy.
1862   * @param exceptions
1863   *          An optional collection in which to place any {@link
1864   *          PropertyException}s that occurred whilst attempting to
1865   *          determine the default values of the Password Policy. This
1866   *          argument can be <code>null<code>.
1867   * @return Returns a new Password Policy configuration instance.
1868   * @throws IllegalManagedObjectNameException
1869   *          If the name of the new Password Policy is invalid.
1870   */
1871  <C extends AuthenticationPolicyCfgClient> C createPasswordPolicy(
1872      ManagedObjectDefinition<C, ? extends AuthenticationPolicyCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1873
1874
1875
1876  /**
1877   * Removes the named Password Policy.
1878   *
1879   * @param name
1880   *          The name of the Password Policy to remove.
1881   * @throws ManagedObjectNotFoundException
1882   *           If the Password Policy does not exist.
1883   * @throws OperationRejectedException
1884   *           If the server refuses to remove the Password Policy due
1885   *           to some server-side constraint which cannot be satisfied
1886   *           (for example, if it is referenced by another managed
1887   *           object).
1888   * @throws ConcurrentModificationException
1889   *           If this Root has been removed from the server by
1890   *           another client.
1891   * @throws LdapException
1892   *           If any other error occurs.
1893   */
1894  void removePasswordPolicy(String name)
1895      throws ManagedObjectNotFoundException, OperationRejectedException,
1896      ConcurrentModificationException, LdapException;
1897
1898
1899
1900  /**
1901   * Lists the Password Storage Schemes.
1902   *
1903   * @return Returns an array containing the names of the Password
1904   *         Storage Schemes.
1905   * @throws ConcurrentModificationException
1906   *           If this Root has been removed from the server by
1907   *           another client.
1908   * @throws LdapException
1909   *           If any other error occurs.
1910   */
1911  String[] listPasswordStorageSchemes() throws ConcurrentModificationException,
1912      LdapException;
1913
1914
1915
1916  /**
1917   * Gets the named Password Storage Scheme.
1918   *
1919   * @param name
1920   *           The name of the Password Storage Scheme to retrieve.
1921   * @return Returns the named Password Storage Scheme.
1922   * @throws DefinitionDecodingException
1923   *           If the named Password Storage Scheme was found but its
1924   *           type could not be determined.
1925   * @throws ManagedObjectDecodingException
1926   *           If the named Password Storage Scheme was found but one
1927   *           or more of its properties could not be decoded.
1928   * @throws ManagedObjectNotFoundException
1929   *           If the named Password Storage Scheme was not found on
1930   *           the server.
1931   * @throws ConcurrentModificationException
1932   *           If this Root has been removed from the server by
1933   *           another client.
1934   * @throws LdapException
1935   *           If any other error occurs.
1936   */
1937  PasswordStorageSchemeCfgClient getPasswordStorageScheme(String name)
1938      throws DefinitionDecodingException, ManagedObjectDecodingException,
1939      ManagedObjectNotFoundException, ConcurrentModificationException,
1940      LdapException;
1941
1942
1943
1944  /**
1945   * Creates a new Password Storage Scheme. The new Password Storage
1946   * Scheme will initially not contain any property values (including
1947   * mandatory properties). Once the Password Storage Scheme has been
1948   * configured it can be added to the server using the {@link
1949   * #commit()} method.
1950   *
1951   * @param <C>
1952   *          The type of the Password Storage Scheme being created.
1953   * @param d
1954   *          The definition of the Password Storage Scheme to be
1955   *          created.
1956   * @param name
1957   *          The name of the new Password Storage Scheme.
1958   * @param exceptions
1959   *          An optional collection in which to place any {@link
1960   *          PropertyException}s that occurred whilst attempting to
1961   *          determine the default values of the Password Storage
1962   *          Scheme. This argument can be <code>null<code>.
1963   * @return Returns a new Password Storage Scheme configuration
1964   *         instance.
1965   * @throws IllegalManagedObjectNameException
1966   *          If the name of the new Password Storage Scheme is
1967   *          invalid.
1968   */
1969  <C extends PasswordStorageSchemeCfgClient> C createPasswordStorageScheme(
1970      ManagedObjectDefinition<C, ? extends PasswordStorageSchemeCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
1971
1972
1973
1974  /**
1975   * Removes the named Password Storage Scheme.
1976   *
1977   * @param name
1978   *          The name of the Password Storage Scheme to remove.
1979   * @throws ManagedObjectNotFoundException
1980   *           If the Password Storage Scheme does not exist.
1981   * @throws OperationRejectedException
1982   *           If the server refuses to remove the Password Storage
1983   *           Scheme due to some server-side constraint which cannot
1984   *           be satisfied (for example, if it is referenced by
1985   *           another managed object).
1986   * @throws ConcurrentModificationException
1987   *           If this Root has been removed from the server by
1988   *           another client.
1989   * @throws LdapException
1990   *           If any other error occurs.
1991   */
1992  void removePasswordStorageScheme(String name)
1993      throws ManagedObjectNotFoundException, OperationRejectedException,
1994      ConcurrentModificationException, LdapException;
1995
1996
1997
1998  /**
1999   * Lists the Password Validators.
2000   *
2001   * @return Returns an array containing the names of the Password
2002   *         Validators.
2003   * @throws ConcurrentModificationException
2004   *           If this Root has been removed from the server by
2005   *           another client.
2006   * @throws LdapException
2007   *           If any other error occurs.
2008   */
2009  String[] listPasswordValidators() throws ConcurrentModificationException,
2010      LdapException;
2011
2012
2013
2014  /**
2015   * Gets the named Password Validator.
2016   *
2017   * @param name
2018   *           The name of the Password Validator to retrieve.
2019   * @return Returns the named Password Validator.
2020   * @throws DefinitionDecodingException
2021   *           If the named Password Validator was found but its type
2022   *           could not be determined.
2023   * @throws ManagedObjectDecodingException
2024   *           If the named Password Validator was found but one or
2025   *           more of its properties could not be decoded.
2026   * @throws ManagedObjectNotFoundException
2027   *           If the named Password Validator was not found on the
2028   *           server.
2029   * @throws ConcurrentModificationException
2030   *           If this Root has been removed from the server by
2031   *           another client.
2032   * @throws LdapException
2033   *           If any other error occurs.
2034   */
2035  PasswordValidatorCfgClient getPasswordValidator(String name)
2036      throws DefinitionDecodingException, ManagedObjectDecodingException,
2037      ManagedObjectNotFoundException, ConcurrentModificationException,
2038      LdapException;
2039
2040
2041
2042  /**
2043   * Creates a new Password Validator. The new Password Validator will
2044   * initially not contain any property values (including mandatory
2045   * properties). Once the Password Validator has been configured it
2046   * can be added to the server using the {@link #commit()} method.
2047   *
2048   * @param <C>
2049   *          The type of the Password Validator being created.
2050   * @param d
2051   *          The definition of the Password Validator to be created.
2052   * @param name
2053   *          The name of the new Password Validator.
2054   * @param exceptions
2055   *          An optional collection in which to place any {@link
2056   *          PropertyException}s that occurred whilst attempting to
2057   *          determine the default values of the Password Validator.
2058   *          This argument can be <code>null<code>.
2059   * @return Returns a new Password Validator configuration instance.
2060   * @throws IllegalManagedObjectNameException
2061   *          If the name of the new Password Validator is invalid.
2062   */
2063  <C extends PasswordValidatorCfgClient> C createPasswordValidator(
2064      ManagedObjectDefinition<C, ? extends PasswordValidatorCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
2065
2066
2067
2068  /**
2069   * Removes the named Password Validator.
2070   *
2071   * @param name
2072   *          The name of the Password Validator to remove.
2073   * @throws ManagedObjectNotFoundException
2074   *           If the Password Validator does not exist.
2075   * @throws OperationRejectedException
2076   *           If the server refuses to remove the Password Validator
2077   *           due to some server-side constraint which cannot be
2078   *           satisfied (for example, if it is referenced by another
2079   *           managed object).
2080   * @throws ConcurrentModificationException
2081   *           If this Root has been removed from the server by
2082   *           another client.
2083   * @throws LdapException
2084   *           If any other error occurs.
2085   */
2086  void removePasswordValidator(String name)
2087      throws ManagedObjectNotFoundException, OperationRejectedException,
2088      ConcurrentModificationException, LdapException;
2089
2090
2091
2092  /**
2093   * Gets the Plugin Root.
2094   *
2095   * @return Returns the Plugin Root.
2096   * @throws DefinitionDecodingException
2097   *           If the Plugin Root was found but its type could not be
2098   *           determined.
2099   * @throws ManagedObjectDecodingException
2100   *           If the Plugin Root was found but one or more of its
2101   *           properties could not be decoded.
2102   * @throws ManagedObjectNotFoundException
2103   *           If the Plugin Root could not be found on the server.
2104   * @throws ConcurrentModificationException
2105   *           If this Root has been removed from the server by
2106   *           another client.
2107   * @throws LdapException
2108   *           If any other error occurs.
2109   */
2110  PluginRootCfgClient getPluginRoot()
2111      throws DefinitionDecodingException, ManagedObjectDecodingException,
2112      ManagedObjectNotFoundException, ConcurrentModificationException,
2113      LdapException;
2114
2115
2116
2117  /**
2118   * Gets the Root DN.
2119   *
2120   * @return Returns the Root DN.
2121   * @throws DefinitionDecodingException
2122   *           If the Root DN was found but its type could not be
2123   *           determined.
2124   * @throws ManagedObjectDecodingException
2125   *           If the Root DN was found but one or more of its
2126   *           properties could not be decoded.
2127   * @throws ManagedObjectNotFoundException
2128   *           If the Root DN could not be found on the server.
2129   * @throws ConcurrentModificationException
2130   *           If this Root has been removed from the server by
2131   *           another client.
2132   * @throws LdapException
2133   *           If any other error occurs.
2134   */
2135  RootDNCfgClient getRootDN()
2136      throws DefinitionDecodingException, ManagedObjectDecodingException,
2137      ManagedObjectNotFoundException, ConcurrentModificationException,
2138      LdapException;
2139
2140
2141
2142  /**
2143   * Gets the Root DSE Backend.
2144   *
2145   * @return Returns the Root DSE Backend.
2146   * @throws DefinitionDecodingException
2147   *           If the Root DSE Backend was found but its type could
2148   *           not be determined.
2149   * @throws ManagedObjectDecodingException
2150   *           If the Root DSE Backend was found but one or more of
2151   *           its properties could not be decoded.
2152   * @throws ManagedObjectNotFoundException
2153   *           If the Root DSE Backend could not be found on the
2154   *           server.
2155   * @throws ConcurrentModificationException
2156   *           If this Root has been removed from the server by
2157   *           another client.
2158   * @throws LdapException
2159   *           If any other error occurs.
2160   */
2161  RootDSEBackendCfgClient getRootDSEBackend()
2162      throws DefinitionDecodingException, ManagedObjectDecodingException,
2163      ManagedObjectNotFoundException, ConcurrentModificationException,
2164      LdapException;
2165
2166
2167
2168  /**
2169   * Lists the SASL Mechanism Handlers.
2170   *
2171   * @return Returns an array containing the names of the SASL
2172   *         Mechanism Handlers.
2173   * @throws ConcurrentModificationException
2174   *           If this Root has been removed from the server by
2175   *           another client.
2176   * @throws LdapException
2177   *           If any other error occurs.
2178   */
2179  String[] listSASLMechanismHandlers() throws ConcurrentModificationException,
2180      LdapException;
2181
2182
2183
2184  /**
2185   * Gets the named SASL Mechanism Handler.
2186   *
2187   * @param name
2188   *           The name of the SASL Mechanism Handler to retrieve.
2189   * @return Returns the named SASL Mechanism Handler.
2190   * @throws DefinitionDecodingException
2191   *           If the named SASL Mechanism Handler was found but its
2192   *           type could not be determined.
2193   * @throws ManagedObjectDecodingException
2194   *           If the named SASL Mechanism Handler was found but one
2195   *           or more of its properties could not be decoded.
2196   * @throws ManagedObjectNotFoundException
2197   *           If the named SASL Mechanism Handler was not found on
2198   *           the server.
2199   * @throws ConcurrentModificationException
2200   *           If this Root has been removed from the server by
2201   *           another client.
2202   * @throws LdapException
2203   *           If any other error occurs.
2204   */
2205  SASLMechanismHandlerCfgClient getSASLMechanismHandler(String name)
2206      throws DefinitionDecodingException, ManagedObjectDecodingException,
2207      ManagedObjectNotFoundException, ConcurrentModificationException,
2208      LdapException;
2209
2210
2211
2212  /**
2213   * Creates a new SASL Mechanism Handler. The new SASL Mechanism
2214   * Handler will initially not contain any property values (including
2215   * mandatory properties). Once the SASL Mechanism Handler has been
2216   * configured it can be added to the server using the {@link
2217   * #commit()} method.
2218   *
2219   * @param <C>
2220   *          The type of the SASL Mechanism Handler being created.
2221   * @param d
2222   *          The definition of the SASL Mechanism Handler to be
2223   *          created.
2224   * @param name
2225   *          The name of the new SASL Mechanism Handler.
2226   * @param exceptions
2227   *          An optional collection in which to place any {@link
2228   *          PropertyException}s that occurred whilst attempting to
2229   *          determine the default values of the SASL Mechanism
2230   *          Handler. This argument can be <code>null<code>.
2231   * @return Returns a new SASL Mechanism Handler configuration
2232   *         instance.
2233   * @throws IllegalManagedObjectNameException
2234   *          If the name of the new SASL Mechanism Handler is
2235   *          invalid.
2236   */
2237  <C extends SASLMechanismHandlerCfgClient> C createSASLMechanismHandler(
2238      ManagedObjectDefinition<C, ? extends SASLMechanismHandlerCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
2239
2240
2241
2242  /**
2243   * Removes the named SASL Mechanism Handler.
2244   *
2245   * @param name
2246   *          The name of the SASL Mechanism Handler to remove.
2247   * @throws ManagedObjectNotFoundException
2248   *           If the SASL Mechanism Handler does not exist.
2249   * @throws OperationRejectedException
2250   *           If the server refuses to remove the SASL Mechanism
2251   *           Handler due to some server-side constraint which cannot
2252   *           be satisfied (for example, if it is referenced by
2253   *           another managed object).
2254   * @throws ConcurrentModificationException
2255   *           If this Root has been removed from the server by
2256   *           another client.
2257   * @throws LdapException
2258   *           If any other error occurs.
2259   */
2260  void removeSASLMechanismHandler(String name)
2261      throws ManagedObjectNotFoundException, OperationRejectedException,
2262      ConcurrentModificationException, LdapException;
2263
2264
2265
2266  /**
2267   * Lists the Schema Providers.
2268   *
2269   * @return Returns an array containing the names of the Schema
2270   *         Providers.
2271   * @throws ConcurrentModificationException
2272   *           If this Root has been removed from the server by
2273   *           another client.
2274   * @throws LdapException
2275   *           If any other error occurs.
2276   */
2277  String[] listSchemaProviders() throws ConcurrentModificationException,
2278      LdapException;
2279
2280
2281
2282  /**
2283   * Gets the named Schema Provider.
2284   *
2285   * @param name
2286   *           The name of the Schema Provider to retrieve.
2287   * @return Returns the named Schema Provider.
2288   * @throws DefinitionDecodingException
2289   *           If the named Schema Provider was found but its type
2290   *           could not be determined.
2291   * @throws ManagedObjectDecodingException
2292   *           If the named Schema Provider was found but one or more
2293   *           of its properties could not be decoded.
2294   * @throws ManagedObjectNotFoundException
2295   *           If the named Schema Provider was not found on the
2296   *           server.
2297   * @throws ConcurrentModificationException
2298   *           If this Root has been removed from the server by
2299   *           another client.
2300   * @throws LdapException
2301   *           If any other error occurs.
2302   */
2303  SchemaProviderCfgClient getSchemaProvider(String name)
2304      throws DefinitionDecodingException, ManagedObjectDecodingException,
2305      ManagedObjectNotFoundException, ConcurrentModificationException,
2306      LdapException;
2307
2308
2309
2310  /**
2311   * Creates a new Schema Provider. The new Schema Provider will
2312   * initially not contain any property values (including mandatory
2313   * properties). Once the Schema Provider has been configured it can
2314   * be added to the server using the {@link #commit()} method.
2315   *
2316   * @param <C>
2317   *          The type of the Schema Provider being created.
2318   * @param d
2319   *          The definition of the Schema Provider to be created.
2320   * @param name
2321   *          The name of the new Schema Provider.
2322   * @param exceptions
2323   *          An optional collection in which to place any {@link
2324   *          PropertyException}s that occurred whilst attempting to
2325   *          determine the default values of the Schema Provider. This
2326   *          argument can be <code>null<code>.
2327   * @return Returns a new Schema Provider configuration instance.
2328   * @throws IllegalManagedObjectNameException
2329   *          If the name of the new Schema Provider is invalid.
2330   */
2331  <C extends SchemaProviderCfgClient> C createSchemaProvider(
2332      ManagedObjectDefinition<C, ? extends SchemaProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
2333
2334
2335
2336  /**
2337   * Removes the named Schema Provider.
2338   *
2339   * @param name
2340   *          The name of the Schema Provider to remove.
2341   * @throws ManagedObjectNotFoundException
2342   *           If the Schema Provider does not exist.
2343   * @throws OperationRejectedException
2344   *           If the server refuses to remove the Schema Provider due
2345   *           to some server-side constraint which cannot be satisfied
2346   *           (for example, if it is referenced by another managed
2347   *           object).
2348   * @throws ConcurrentModificationException
2349   *           If this Root has been removed from the server by
2350   *           another client.
2351   * @throws LdapException
2352   *           If any other error occurs.
2353   */
2354  void removeSchemaProvider(String name)
2355      throws ManagedObjectNotFoundException, OperationRejectedException,
2356      ConcurrentModificationException, LdapException;
2357
2358
2359
2360  /**
2361   * Lists the Synchronization Providers.
2362   *
2363   * @return Returns an array containing the names of the
2364   *         Synchronization Providers.
2365   * @throws ConcurrentModificationException
2366   *           If this Root has been removed from the server by
2367   *           another client.
2368   * @throws LdapException
2369   *           If any other error occurs.
2370   */
2371  String[] listSynchronizationProviders() throws ConcurrentModificationException,
2372      LdapException;
2373
2374
2375
2376  /**
2377   * Gets the named Synchronization Provider.
2378   *
2379   * @param name
2380   *           The name of the Synchronization Provider to retrieve.
2381   * @return Returns the named Synchronization Provider.
2382   * @throws DefinitionDecodingException
2383   *           If the named Synchronization Provider was found but its
2384   *           type could not be determined.
2385   * @throws ManagedObjectDecodingException
2386   *           If the named Synchronization Provider was found but one
2387   *           or more of its properties could not be decoded.
2388   * @throws ManagedObjectNotFoundException
2389   *           If the named Synchronization Provider was not found on
2390   *           the server.
2391   * @throws ConcurrentModificationException
2392   *           If this Root has been removed from the server by
2393   *           another client.
2394   * @throws LdapException
2395   *           If any other error occurs.
2396   */
2397  SynchronizationProviderCfgClient getSynchronizationProvider(String name)
2398      throws DefinitionDecodingException, ManagedObjectDecodingException,
2399      ManagedObjectNotFoundException, ConcurrentModificationException,
2400      LdapException;
2401
2402
2403
2404  /**
2405   * Creates a new Synchronization Provider. The new Synchronization
2406   * Provider will initially not contain any property values (including
2407   * mandatory properties). Once the Synchronization Provider has been
2408   * configured it can be added to the server using the {@link
2409   * #commit()} method.
2410   *
2411   * @param <C>
2412   *          The type of the Synchronization Provider being created.
2413   * @param d
2414   *          The definition of the Synchronization Provider to be
2415   *          created.
2416   * @param name
2417   *          The name of the new Synchronization Provider.
2418   * @param exceptions
2419   *          An optional collection in which to place any {@link
2420   *          PropertyException}s that occurred whilst attempting to
2421   *          determine the default values of the Synchronization
2422   *          Provider. This argument can be <code>null<code>.
2423   * @return Returns a new Synchronization Provider configuration
2424   *         instance.
2425   * @throws IllegalManagedObjectNameException
2426   *          If the name of the new Synchronization Provider is
2427   *          invalid.
2428   */
2429  <C extends SynchronizationProviderCfgClient> C createSynchronizationProvider(
2430      ManagedObjectDefinition<C, ? extends SynchronizationProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
2431
2432
2433
2434  /**
2435   * Removes the named Synchronization Provider.
2436   *
2437   * @param name
2438   *          The name of the Synchronization Provider to remove.
2439   * @throws ManagedObjectNotFoundException
2440   *           If the Synchronization Provider does not exist.
2441   * @throws OperationRejectedException
2442   *           If the server refuses to remove the Synchronization
2443   *           Provider due to some server-side constraint which cannot
2444   *           be satisfied (for example, if it is referenced by
2445   *           another managed object).
2446   * @throws ConcurrentModificationException
2447   *           If this Root has been removed from the server by
2448   *           another client.
2449   * @throws LdapException
2450   *           If any other error occurs.
2451   */
2452  void removeSynchronizationProvider(String name)
2453      throws ManagedObjectNotFoundException, OperationRejectedException,
2454      ConcurrentModificationException, LdapException;
2455
2456
2457
2458  /**
2459   * Lists the Trust Manager Providers.
2460   *
2461   * @return Returns an array containing the names of the Trust
2462   *         Manager Providers.
2463   * @throws ConcurrentModificationException
2464   *           If this Root has been removed from the server by
2465   *           another client.
2466   * @throws LdapException
2467   *           If any other error occurs.
2468   */
2469  String[] listTrustManagerProviders() throws ConcurrentModificationException,
2470      LdapException;
2471
2472
2473
2474  /**
2475   * Gets the named Trust Manager Provider.
2476   *
2477   * @param name
2478   *           The name of the Trust Manager Provider to retrieve.
2479   * @return Returns the named Trust Manager Provider.
2480   * @throws DefinitionDecodingException
2481   *           If the named Trust Manager Provider was found but its
2482   *           type could not be determined.
2483   * @throws ManagedObjectDecodingException
2484   *           If the named Trust Manager Provider was found but one
2485   *           or more of its properties could not be decoded.
2486   * @throws ManagedObjectNotFoundException
2487   *           If the named Trust Manager Provider was not found on
2488   *           the server.
2489   * @throws ConcurrentModificationException
2490   *           If this Root has been removed from the server by
2491   *           another client.
2492   * @throws LdapException
2493   *           If any other error occurs.
2494   */
2495  TrustManagerProviderCfgClient getTrustManagerProvider(String name)
2496      throws DefinitionDecodingException, ManagedObjectDecodingException,
2497      ManagedObjectNotFoundException, ConcurrentModificationException,
2498      LdapException;
2499
2500
2501
2502  /**
2503   * Creates a new Trust Manager Provider. The new Trust Manager
2504   * Provider will initially not contain any property values (including
2505   * mandatory properties). Once the Trust Manager Provider has been
2506   * configured it can be added to the server using the {@link
2507   * #commit()} method.
2508   *
2509   * @param <C>
2510   *          The type of the Trust Manager Provider being created.
2511   * @param d
2512   *          The definition of the Trust Manager Provider to be
2513   *          created.
2514   * @param name
2515   *          The name of the new Trust Manager Provider.
2516   * @param exceptions
2517   *          An optional collection in which to place any {@link
2518   *          PropertyException}s that occurred whilst attempting to
2519   *          determine the default values of the Trust Manager
2520   *          Provider. This argument can be <code>null<code>.
2521   * @return Returns a new Trust Manager Provider configuration
2522   *         instance.
2523   * @throws IllegalManagedObjectNameException
2524   *          If the name of the new Trust Manager Provider is
2525   *          invalid.
2526   */
2527  <C extends TrustManagerProviderCfgClient> C createTrustManagerProvider(
2528      ManagedObjectDefinition<C, ? extends TrustManagerProviderCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
2529
2530
2531
2532  /**
2533   * Removes the named Trust Manager Provider.
2534   *
2535   * @param name
2536   *          The name of the Trust Manager Provider to remove.
2537   * @throws ManagedObjectNotFoundException
2538   *           If the Trust Manager Provider does not exist.
2539   * @throws OperationRejectedException
2540   *           If the server refuses to remove the Trust Manager
2541   *           Provider due to some server-side constraint which cannot
2542   *           be satisfied (for example, if it is referenced by
2543   *           another managed object).
2544   * @throws ConcurrentModificationException
2545   *           If this Root has been removed from the server by
2546   *           another client.
2547   * @throws LdapException
2548   *           If any other error occurs.
2549   */
2550  void removeTrustManagerProvider(String name)
2551      throws ManagedObjectNotFoundException, OperationRejectedException,
2552      ConcurrentModificationException, LdapException;
2553
2554
2555
2556  /**
2557   * Lists the Virtual Attributes.
2558   *
2559   * @return Returns an array containing the names of the Virtual
2560   *         Attributes.
2561   * @throws ConcurrentModificationException
2562   *           If this Root has been removed from the server by
2563   *           another client.
2564   * @throws LdapException
2565   *           If any other error occurs.
2566   */
2567  String[] listVirtualAttributes() throws ConcurrentModificationException,
2568      LdapException;
2569
2570
2571
2572  /**
2573   * Gets the named Virtual Attribute.
2574   *
2575   * @param name
2576   *           The name of the Virtual Attribute to retrieve.
2577   * @return Returns the named Virtual Attribute.
2578   * @throws DefinitionDecodingException
2579   *           If the named Virtual Attribute was found but its type
2580   *           could not be determined.
2581   * @throws ManagedObjectDecodingException
2582   *           If the named Virtual Attribute was found but one or
2583   *           more of its properties could not be decoded.
2584   * @throws ManagedObjectNotFoundException
2585   *           If the named Virtual Attribute was not found on the
2586   *           server.
2587   * @throws ConcurrentModificationException
2588   *           If this Root has been removed from the server by
2589   *           another client.
2590   * @throws LdapException
2591   *           If any other error occurs.
2592   */
2593  VirtualAttributeCfgClient getVirtualAttribute(String name)
2594      throws DefinitionDecodingException, ManagedObjectDecodingException,
2595      ManagedObjectNotFoundException, ConcurrentModificationException,
2596      LdapException;
2597
2598
2599
2600  /**
2601   * Creates a new Virtual Attribute. The new Virtual Attribute will
2602   * initially not contain any property values (including mandatory
2603   * properties). Once the Virtual Attribute has been configured it can
2604   * be added to the server using the {@link #commit()} method.
2605   *
2606   * @param <C>
2607   *          The type of the Virtual Attribute being created.
2608   * @param d
2609   *          The definition of the Virtual Attribute to be created.
2610   * @param name
2611   *          The name of the new Virtual Attribute.
2612   * @param exceptions
2613   *          An optional collection in which to place any {@link
2614   *          PropertyException}s that occurred whilst attempting to
2615   *          determine the default values of the Virtual Attribute.
2616   *          This argument can be <code>null<code>.
2617   * @return Returns a new Virtual Attribute configuration instance.
2618   * @throws IllegalManagedObjectNameException
2619   *          If the name of the new Virtual Attribute is invalid.
2620   */
2621  <C extends VirtualAttributeCfgClient> C createVirtualAttribute(
2622      ManagedObjectDefinition<C, ? extends VirtualAttributeCfg> d, String name, Collection<PropertyException> exceptions) throws IllegalManagedObjectNameException;
2623
2624
2625
2626  /**
2627   * Removes the named Virtual Attribute.
2628   *
2629   * @param name
2630   *          The name of the Virtual Attribute to remove.
2631   * @throws ManagedObjectNotFoundException
2632   *           If the Virtual Attribute does not exist.
2633   * @throws OperationRejectedException
2634   *           If the server refuses to remove the Virtual Attribute
2635   *           due to some server-side constraint which cannot be
2636   *           satisfied (for example, if it is referenced by another
2637   *           managed object).
2638   * @throws ConcurrentModificationException
2639   *           If this Root has been removed from the server by
2640   *           another client.
2641   * @throws LdapException
2642   *           If any other error occurs.
2643   */
2644  void removeVirtualAttribute(String name)
2645      throws ManagedObjectNotFoundException, OperationRejectedException,
2646      ConcurrentModificationException, LdapException;
2647
2648
2649
2650  /**
2651   * Gets the Work Queue.
2652   *
2653   * @return Returns the Work Queue.
2654   * @throws DefinitionDecodingException
2655   *           If the Work Queue was found but its type could not be
2656   *           determined.
2657   * @throws ManagedObjectDecodingException
2658   *           If the Work Queue was found but one or more of its
2659   *           properties could not be decoded.
2660   * @throws ManagedObjectNotFoundException
2661   *           If the Work Queue could not be found on the server.
2662   * @throws ConcurrentModificationException
2663   *           If this Root has been removed from the server by
2664   *           another client.
2665   * @throws LdapException
2666   *           If any other error occurs.
2667   */
2668  WorkQueueCfgClient getWorkQueue()
2669      throws DefinitionDecodingException, ManagedObjectDecodingException,
2670      ManagedObjectNotFoundException, ConcurrentModificationException,
2671      LdapException;
2672
2673}