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