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