/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the ds-2015-04-16.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.DirectoryService.Model; using Amazon.DirectoryService.Model.Internal.MarshallTransformations; using Amazon.DirectoryService.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.DirectoryService { ///

/// Implementation for accessing DirectoryService /// /// Directory Service /// /// Directory Service is a web service that makes it easy for you to setup and run directories /// in the Amazon Web Services cloud, or connect your Amazon Web Services resources with /// an existing self-managed Microsoft Active Directory. This guide provides detailed /// information about Directory Service operations, data types, parameters, and errors. /// For information about Directory Services features, see Directory /// Service and the Directory /// Service Administration Guide. /// /// /// /// Amazon Web Services provides SDKs that consist of libraries and sample code for various /// programming languages and platforms (Java, Ruby, .Net, iOS, Android, etc.). The SDKs /// provide a convenient way to create programmatic access to Directory Service and other /// Amazon Web Services services. For more information about the Amazon Web Services SDKs, /// including how to download and install them, see Tools /// for Amazon Web Services. /// /// ///

public partial class AmazonDirectoryServiceClient : AmazonServiceClient, IAmazonDirectoryService { private static IServiceMetadata serviceMetadata = new AmazonDirectoryServiceMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IDirectoryServicePaginatorFactory _paginators; ///

/// Paginators for the service ///

public IDirectoryServicePaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new DirectoryServicePaginatorFactory(this); } return this._paginators; } } #endif #region Constructors ///

/// Constructs AmazonDirectoryServiceClient with the credentials loaded from the application's /// default configuration, and if unsuccessful from the Instance Profile service on an EC2 instance. /// /// Example App.config with credentials set. ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

public AmazonDirectoryServiceClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonDirectoryServiceConfig()) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The region to connect. public AmazonDirectoryServiceClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonDirectoryServiceConfig{RegionEndpoint = region}) { } ///


        /// <?xml version="1.0" encoding="utf-8" ?>
        /// <configuration>
        ///     <appSettings>
        ///         <add key="AWSProfileName" value="AWS Default"/>
        ///     </appSettings>
        /// </configuration>
        ///

/// ///

/// The AmazonDirectoryServiceClient Configuration Object public AmazonDirectoryServiceClient(AmazonDirectoryServiceConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} ///

/// Constructs AmazonDirectoryServiceClient with AWS Credentials ///

/// AWS Credentials public AmazonDirectoryServiceClient(AWSCredentials credentials) : this(credentials, new AmazonDirectoryServiceConfig()) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Credentials ///

/// AWS Credentials /// The region to connect. public AmazonDirectoryServiceClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonDirectoryServiceConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Credentials and an /// AmazonDirectoryServiceClient Configuration object. ///

/// AWS Credentials /// The AmazonDirectoryServiceClient Configuration Object public AmazonDirectoryServiceClient(AWSCredentials credentials, AmazonDirectoryServiceConfig clientConfig) : base(credentials, clientConfig) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key public AmazonDirectoryServiceClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonDirectoryServiceConfig()) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonDirectoryServiceClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonDirectoryServiceConfig() {RegionEndpoint=region}) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Access Key ID, AWS Secret Key and an /// AmazonDirectoryServiceClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// The AmazonDirectoryServiceClient Configuration Object public AmazonDirectoryServiceClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonDirectoryServiceConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonDirectoryServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonDirectoryServiceConfig()) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Access Key ID and AWS Secret Key ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The region to connect. public AmazonDirectoryServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonDirectoryServiceConfig{RegionEndpoint = region}) { } ///

/// Constructs AmazonDirectoryServiceClient with AWS Access Key ID, AWS Secret Key and an /// AmazonDirectoryServiceClient Configuration object. ///

/// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonDirectoryServiceClient Configuration Object public AmazonDirectoryServiceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonDirectoryServiceConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, clientConfig) { } #endregion #region Overrides ///

/// Creates the signer for the service. ///

protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } ///

/// Customize the pipeline ///

/// protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new AmazonDirectoryServiceEndpointResolver()); } ///

/// Capture metadata for the service. ///

protected override IServiceMetadata ServiceMetadata { get { return serviceMetadata; } } #endregion #region Dispose ///

/// Disposes the service client. ///

protected override void Dispose(bool disposing) { base.Dispose(disposing); } #endregion #region AcceptSharedDirectory ///

/// Accepts a directory sharing request that was sent from the directory owner account. ///

/// Container for the necessary parameters to execute the AcceptSharedDirectory service method. /// /// The response from the AcceptSharedDirectory service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory has already been shared with this Amazon Web Services account. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for AcceptSharedDirectory Operation public virtual AcceptSharedDirectoryResponse AcceptSharedDirectory(AcceptSharedDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptSharedDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AcceptSharedDirectory operation. ///

/// /// Container for the necessary parameters to execute the AcceptSharedDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAcceptSharedDirectory /// operation. /// REST API Reference for AcceptSharedDirectory Operation public virtual IAsyncResult BeginAcceptSharedDirectory(AcceptSharedDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptSharedDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AcceptSharedDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginAcceptSharedDirectory. /// /// Returns a AcceptSharedDirectoryResult from DirectoryService. /// REST API Reference for AcceptSharedDirectory Operation public virtual AcceptSharedDirectoryResponse EndAcceptSharedDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AddIpRoutes ///

/// If the DNS server for your self-managed domain uses a publicly addressable IP address, /// you must add a CIDR address block to correctly route traffic to and from your Microsoft /// AD on Amazon Web Services. AddIpRoutes adds this address block. You can also /// use AddIpRoutes to facilitate routing traffic that uses public IP ranges from /// your Microsoft AD on Amazon Web Services to a peer VPC. /// /// /// /// Before you call AddIpRoutes, ensure that all of the required permissions have /// been explicitly granted through a policy. For details about what permissions are required /// to run the AddIpRoutes operation, see Directory /// Service API Permissions: Actions, Resources, and Conditions Reference. /// ///

/// Container for the necessary parameters to execute the AddIpRoutes service method. /// /// The response from the AddIpRoutes service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity already exists. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// The maximum allowed number of IP addresses was exceeded. The default limit is 100 /// IP address blocks. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for AddIpRoutes Operation public virtual AddIpRoutesResponse AddIpRoutes(AddIpRoutesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = AddIpRoutesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AddIpRoutes operation. ///

/// /// Container for the necessary parameters to execute the AddIpRoutes operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAddIpRoutes /// operation. /// REST API Reference for AddIpRoutes Operation public virtual IAsyncResult BeginAddIpRoutes(AddIpRoutesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AddIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = AddIpRoutesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AddIpRoutes operation. ///

/// /// The IAsyncResult returned by the call to BeginAddIpRoutes. /// /// Returns a AddIpRoutesResult from DirectoryService. /// REST API Reference for AddIpRoutes Operation public virtual AddIpRoutesResponse EndAddIpRoutes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AddRegion ///

/// Adds two domain controllers in the specified Region for the specified directory. ///

/// Container for the necessary parameters to execute the AddRegion service method. /// /// The response from the AddRegion service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The Region you specified is the same Region where the Managed Microsoft AD directory /// was created. Specify a different Region and try again. /// /// /// The specified directory does not exist in the system. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// You have reached the limit for maximum number of simultaneous Region replications /// per directory. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for AddRegion Operation public virtual AddRegionResponse AddRegion(AddRegionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRegionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AddRegion operation. ///

/// /// Container for the necessary parameters to execute the AddRegion operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAddRegion /// operation. /// REST API Reference for AddRegion Operation public virtual IAsyncResult BeginAddRegion(AddRegionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AddRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRegionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AddRegion operation. ///

/// /// The IAsyncResult returned by the call to BeginAddRegion. /// /// Returns a AddRegionResult from DirectoryService. /// REST API Reference for AddRegion Operation public virtual AddRegionResponse EndAddRegion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region AddTagsToResource ///

/// Adds or overwrites one or more tags for the specified directory. Each directory can /// have a maximum of 50 tags. Each tag consists of a key and optional value. Tag keys /// must be unique to each resource. ///

/// Container for the necessary parameters to execute the AddTagsToResource service method. /// /// The response from the AddTagsToResource service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The maximum allowed number of tags was exceeded. /// /// REST API Reference for AddTagsToResource Operation public virtual AddTagsToResourceResponse AddTagsToResource(AddTagsToResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the AddTagsToResource operation. ///

/// /// Container for the necessary parameters to execute the AddTagsToResource operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndAddTagsToResource /// operation. /// REST API Reference for AddTagsToResource Operation public virtual IAsyncResult BeginAddTagsToResource(AddTagsToResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the AddTagsToResource operation. ///

/// /// The IAsyncResult returned by the call to BeginAddTagsToResource. /// /// Returns a AddTagsToResourceResult from DirectoryService. /// REST API Reference for AddTagsToResource Operation public virtual AddTagsToResourceResponse EndAddTagsToResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CancelSchemaExtension ///

/// Cancels an in-progress schema extension to a Microsoft AD directory. Once a schema /// extension has started replicating to all domain controllers, the task can no longer /// be canceled. A schema extension can be canceled during any of the following states; /// Initializing, CreatingSnapshot, and UpdatingSchema. ///

/// Container for the necessary parameters to execute the CancelSchemaExtension service method. /// /// The response from the CancelSchemaExtension service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for CancelSchemaExtension Operation public virtual CancelSchemaExtensionResponse CancelSchemaExtension(CancelSchemaExtensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSchemaExtensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CancelSchemaExtension operation. ///

/// /// Container for the necessary parameters to execute the CancelSchemaExtension operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCancelSchemaExtension /// operation. /// REST API Reference for CancelSchemaExtension Operation public virtual IAsyncResult BeginCancelSchemaExtension(CancelSchemaExtensionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSchemaExtensionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CancelSchemaExtension operation. ///

/// /// The IAsyncResult returned by the call to BeginCancelSchemaExtension. /// /// Returns a CancelSchemaExtensionResult from DirectoryService. /// REST API Reference for CancelSchemaExtension Operation public virtual CancelSchemaExtensionResponse EndCancelSchemaExtension(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ConnectDirectory ///

/// Creates an AD Connector to connect to a self-managed directory. /// /// /// /// Before you call ConnectDirectory, ensure that all of the required permissions /// have been explicitly granted through a policy. For details about what permissions /// are required to run the ConnectDirectory operation, see Directory /// Service API Permissions: Actions, Resources, and Conditions Reference. /// ///

/// Container for the necessary parameters to execute the ConnectDirectory service method. /// /// The response from the ConnectDirectory service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The maximum number of directories in the region has been reached. You can use the /// GetDirectoryLimits operation to determine your directory limits in the region. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for ConnectDirectory Operation public virtual ConnectDirectoryResponse ConnectDirectory(ConnectDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ConnectDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ConnectDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ConnectDirectory operation. ///

/// /// Container for the necessary parameters to execute the ConnectDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndConnectDirectory /// operation. /// REST API Reference for ConnectDirectory Operation public virtual IAsyncResult BeginConnectDirectory(ConnectDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ConnectDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ConnectDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ConnectDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginConnectDirectory. /// /// Returns a ConnectDirectoryResult from DirectoryService. /// REST API Reference for ConnectDirectory Operation public virtual ConnectDirectoryResponse EndConnectDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateAlias ///

/// Creates an alias for a directory and assigns the alias to the directory. The alias /// is used to construct the access URL for the directory, such as http://<alias>.awsapps.com. /// /// /// /// After an alias has been created, it cannot be deleted or reused, so this operation /// should only be used when absolutely necessary. /// /// ///

/// Container for the necessary parameters to execute the CreateAlias service method. /// /// The response from the CreateAlias service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity already exists. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for CreateAlias Operation public virtual CreateAliasResponse CreateAlias(CreateAliasRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAliasResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateAlias operation. ///

/// /// Container for the necessary parameters to execute the CreateAlias operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateAlias /// operation. /// REST API Reference for CreateAlias Operation public virtual IAsyncResult BeginCreateAlias(CreateAliasRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAliasResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateAlias operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateAlias. /// /// Returns a CreateAliasResult from DirectoryService. /// REST API Reference for CreateAlias Operation public virtual CreateAliasResponse EndCreateAlias(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateComputer ///

/// Creates an Active Directory computer object in the specified directory. ///

/// Container for the necessary parameters to execute the CreateComputer service method. /// /// The response from the CreateComputer service method, as returned by DirectoryService. /// /// An authentication error occurred. /// /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity already exists. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for CreateComputer Operation public virtual CreateComputerResponse CreateComputer(CreateComputerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateComputerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateComputerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateComputer operation. ///

/// /// Container for the necessary parameters to execute the CreateComputer operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateComputer /// operation. /// REST API Reference for CreateComputer Operation public virtual IAsyncResult BeginCreateComputer(CreateComputerRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateComputerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateComputerResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateComputer operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateComputer. /// /// Returns a CreateComputerResult from DirectoryService. /// REST API Reference for CreateComputer Operation public virtual CreateComputerResponse EndCreateComputer(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateConditionalForwarder ///

/// Creates a conditional forwarder associated with your Amazon Web Services directory. /// Conditional forwarders are required in order to set up a trust relationship with another /// domain. The conditional forwarder points to the trusted domain. ///

/// Container for the necessary parameters to execute the CreateConditionalForwarder service method. /// /// The response from the CreateConditionalForwarder service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity already exists. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for CreateConditionalForwarder Operation public virtual CreateConditionalForwarderResponse CreateConditionalForwarder(CreateConditionalForwarderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConditionalForwarderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateConditionalForwarder operation. ///

/// /// Container for the necessary parameters to execute the CreateConditionalForwarder operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateConditionalForwarder /// operation. /// REST API Reference for CreateConditionalForwarder Operation public virtual IAsyncResult BeginCreateConditionalForwarder(CreateConditionalForwarderRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConditionalForwarderResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateConditionalForwarder operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateConditionalForwarder. /// /// Returns a CreateConditionalForwarderResult from DirectoryService. /// REST API Reference for CreateConditionalForwarder Operation public virtual CreateConditionalForwarderResponse EndCreateConditionalForwarder(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateDirectory ///

/// Creates a Simple AD directory. For more information, see Simple /// Active Directory in the Directory Service Admin Guide. /// /// /// /// Before you call CreateDirectory, ensure that all of the required permissions /// have been explicitly granted through a policy. For details about what permissions /// are required to run the CreateDirectory operation, see Directory /// Service API Permissions: Actions, Resources, and Conditions Reference. /// ///

/// Container for the necessary parameters to execute the CreateDirectory service method. /// /// The response from the CreateDirectory service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The maximum number of directories in the region has been reached. You can use the /// GetDirectoryLimits operation to determine your directory limits in the region. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for CreateDirectory Operation public virtual CreateDirectoryResponse CreateDirectory(CreateDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateDirectory operation. ///

/// /// Container for the necessary parameters to execute the CreateDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateDirectory /// operation. /// REST API Reference for CreateDirectory Operation public virtual IAsyncResult BeginCreateDirectory(CreateDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateDirectory. /// /// Returns a CreateDirectoryResult from DirectoryService. /// REST API Reference for CreateDirectory Operation public virtual CreateDirectoryResponse EndCreateDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateLogSubscription ///

/// Creates a subscription to forward real-time Directory Service domain controller security /// logs to the specified Amazon CloudWatch log group in your Amazon Web Services account. ///

/// Container for the necessary parameters to execute the CreateLogSubscription service method. /// /// The response from the CreateLogSubscription service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity already exists. /// /// /// The specified entity could not be found. /// /// /// The account does not have sufficient permission to perform the operation. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for CreateLogSubscription Operation public virtual CreateLogSubscriptionResponse CreateLogSubscription(CreateLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateLogSubscription operation. ///

/// /// Container for the necessary parameters to execute the CreateLogSubscription operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateLogSubscription /// operation. /// REST API Reference for CreateLogSubscription Operation public virtual IAsyncResult BeginCreateLogSubscription(CreateLogSubscriptionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLogSubscriptionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateLogSubscription operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateLogSubscription. /// /// Returns a CreateLogSubscriptionResult from DirectoryService. /// REST API Reference for CreateLogSubscription Operation public virtual CreateLogSubscriptionResponse EndCreateLogSubscription(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateMicrosoftAD ///

/// Creates a Microsoft AD directory in the Amazon Web Services Cloud. For more information, /// see Managed /// Microsoft AD in the Directory Service Admin Guide. /// /// /// /// Before you call CreateMicrosoftAD, ensure that all of the required permissions /// have been explicitly granted through a policy. For details about what permissions /// are required to run the CreateMicrosoftAD operation, see Directory /// Service API Permissions: Actions, Resources, and Conditions Reference. /// ///

/// Container for the necessary parameters to execute the CreateMicrosoftAD service method. /// /// The response from the CreateMicrosoftAD service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The maximum number of directories in the region has been reached. You can use the /// GetDirectoryLimits operation to determine your directory limits in the region. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for CreateMicrosoftAD Operation public virtual CreateMicrosoftADResponse CreateMicrosoftAD(CreateMicrosoftADRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMicrosoftADRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMicrosoftADResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateMicrosoftAD operation. ///

/// /// Container for the necessary parameters to execute the CreateMicrosoftAD operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateMicrosoftAD /// operation. /// REST API Reference for CreateMicrosoftAD Operation public virtual IAsyncResult BeginCreateMicrosoftAD(CreateMicrosoftADRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMicrosoftADRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMicrosoftADResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateMicrosoftAD operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateMicrosoftAD. /// /// Returns a CreateMicrosoftADResult from DirectoryService. /// REST API Reference for CreateMicrosoftAD Operation public virtual CreateMicrosoftADResponse EndCreateMicrosoftAD(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSnapshot ///

/// Creates a snapshot of a Simple AD or Microsoft AD directory in the Amazon Web Services /// cloud. /// /// /// /// You cannot take snapshots of AD Connector directories. /// /// ///

/// Container for the necessary parameters to execute the CreateSnapshot service method. /// /// The response from the CreateSnapshot service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The maximum number of manual snapshots for the directory has been reached. You can /// use the GetSnapshotLimits operation to determine the snapshot limits for a /// directory. /// /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateSnapshot operation. ///

/// /// Container for the necessary parameters to execute the CreateSnapshot operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSnapshot /// operation. /// REST API Reference for CreateSnapshot Operation public virtual IAsyncResult BeginCreateSnapshot(CreateSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateSnapshot. /// /// Returns a CreateSnapshotResult from DirectoryService. /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse EndCreateSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateTrust ///

/// Directory Service for Microsoft Active Directory allows you to configure trust relationships. /// For example, you can establish a trust between your Managed Microsoft AD directory, /// and your existing self-managed Microsoft Active Directory. This would allow you to /// provide users and groups access to resources in either domain, with a single set of /// credentials. /// /// /// /// This action initiates the creation of the Amazon Web Services side of a trust relationship /// between an Managed Microsoft AD directory and an external domain. You can create either /// a forest trust or an external trust. /// ///

/// Container for the necessary parameters to execute the CreateTrust service method. /// /// The response from the CreateTrust service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity already exists. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for CreateTrust Operation public virtual CreateTrustResponse CreateTrust(CreateTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the CreateTrust operation. ///

/// /// Container for the necessary parameters to execute the CreateTrust operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateTrust /// operation. /// REST API Reference for CreateTrust Operation public virtual IAsyncResult BeginCreateTrust(CreateTrustRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrustResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the CreateTrust operation. ///

/// /// The IAsyncResult returned by the call to BeginCreateTrust. /// /// Returns a CreateTrustResult from DirectoryService. /// REST API Reference for CreateTrust Operation public virtual CreateTrustResponse EndCreateTrust(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteConditionalForwarder ///

/// Deletes a conditional forwarder that has been set up for your Amazon Web Services /// directory. ///

/// Container for the necessary parameters to execute the DeleteConditionalForwarder service method. /// /// The response from the DeleteConditionalForwarder service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DeleteConditionalForwarder Operation public virtual DeleteConditionalForwarderResponse DeleteConditionalForwarder(DeleteConditionalForwarderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConditionalForwarderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteConditionalForwarder operation. ///

/// /// Container for the necessary parameters to execute the DeleteConditionalForwarder operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteConditionalForwarder /// operation. /// REST API Reference for DeleteConditionalForwarder Operation public virtual IAsyncResult BeginDeleteConditionalForwarder(DeleteConditionalForwarderRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConditionalForwarderResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteConditionalForwarder operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteConditionalForwarder. /// /// Returns a DeleteConditionalForwarderResult from DirectoryService. /// REST API Reference for DeleteConditionalForwarder Operation public virtual DeleteConditionalForwarderResponse EndDeleteConditionalForwarder(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteDirectory ///

/// Deletes an Directory Service directory. /// /// /// /// Before you call DeleteDirectory, ensure that all of the required permissions /// have been explicitly granted through a policy. For details about what permissions /// are required to run the DeleteDirectory operation, see Directory /// Service API Permissions: Actions, Resources, and Conditions Reference. /// ///

/// Container for the necessary parameters to execute the DeleteDirectory service method. /// /// The response from the DeleteDirectory service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DeleteDirectory Operation public virtual DeleteDirectoryResponse DeleteDirectory(DeleteDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteDirectory operation. ///

/// /// Container for the necessary parameters to execute the DeleteDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteDirectory /// operation. /// REST API Reference for DeleteDirectory Operation public virtual IAsyncResult BeginDeleteDirectory(DeleteDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteDirectory. /// /// Returns a DeleteDirectoryResult from DirectoryService. /// REST API Reference for DeleteDirectory Operation public virtual DeleteDirectoryResponse EndDeleteDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteLogSubscription ///

/// Deletes the specified log subscription. ///

/// Container for the necessary parameters to execute the DeleteLogSubscription service method. /// /// The response from the DeleteLogSubscription service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DeleteLogSubscription Operation public virtual DeleteLogSubscriptionResponse DeleteLogSubscription(DeleteLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteLogSubscription operation. ///

/// /// Container for the necessary parameters to execute the DeleteLogSubscription operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteLogSubscription /// operation. /// REST API Reference for DeleteLogSubscription Operation public virtual IAsyncResult BeginDeleteLogSubscription(DeleteLogSubscriptionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLogSubscriptionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteLogSubscription operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteLogSubscription. /// /// Returns a DeleteLogSubscriptionResult from DirectoryService. /// REST API Reference for DeleteLogSubscription Operation public virtual DeleteLogSubscriptionResponse EndDeleteLogSubscription(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteSnapshot ///

/// Deletes a directory snapshot. ///

/// Container for the necessary parameters to execute the DeleteSnapshot service method. /// /// The response from the DeleteSnapshot service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DeleteSnapshot Operation public virtual DeleteSnapshotResponse DeleteSnapshot(DeleteSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteSnapshot operation. ///

/// /// Container for the necessary parameters to execute the DeleteSnapshot operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSnapshot /// operation. /// REST API Reference for DeleteSnapshot Operation public virtual IAsyncResult BeginDeleteSnapshot(DeleteSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteSnapshot. /// /// Returns a DeleteSnapshotResult from DirectoryService. /// REST API Reference for DeleteSnapshot Operation public virtual DeleteSnapshotResponse EndDeleteSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteTrust ///

/// Deletes an existing trust relationship between your Managed Microsoft AD directory /// and an external domain. ///

/// Container for the necessary parameters to execute the DeleteTrust service method. /// /// The response from the DeleteTrust service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DeleteTrust Operation public virtual DeleteTrustResponse DeleteTrust(DeleteTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeleteTrust operation. ///

/// /// Container for the necessary parameters to execute the DeleteTrust operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteTrust /// operation. /// REST API Reference for DeleteTrust Operation public virtual IAsyncResult BeginDeleteTrust(DeleteTrustRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTrustResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeleteTrust operation. ///

/// /// The IAsyncResult returned by the call to BeginDeleteTrust. /// /// Returns a DeleteTrustResult from DirectoryService. /// REST API Reference for DeleteTrust Operation public virtual DeleteTrustResponse EndDeleteTrust(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterCertificate ///

/// Deletes from the system the certificate that was registered for secure LDAP or client /// certificate authentication. ///

/// Container for the necessary parameters to execute the DeregisterCertificate service method. /// /// The response from the DeregisterCertificate service method, as returned by DirectoryService. /// /// The certificate is not present in the system for describe or deregister activities. /// /// /// The certificate is being used for the LDAP security connection and cannot be removed /// without disabling LDAP security. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The specified directory is unavailable or could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DeregisterCertificate Operation public virtual DeregisterCertificateResponse DeregisterCertificate(DeregisterCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeregisterCertificate operation. ///

/// /// Container for the necessary parameters to execute the DeregisterCertificate operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterCertificate /// operation. /// REST API Reference for DeregisterCertificate Operation public virtual IAsyncResult BeginDeregisterCertificate(DeregisterCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeregisterCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginDeregisterCertificate. /// /// Returns a DeregisterCertificateResult from DirectoryService. /// REST API Reference for DeregisterCertificate Operation public virtual DeregisterCertificateResponse EndDeregisterCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeregisterEventTopic ///

/// Removes the specified directory as a publisher to the specified Amazon SNS topic. ///

/// Container for the necessary parameters to execute the DeregisterEventTopic service method. /// /// The response from the DeregisterEventTopic service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DeregisterEventTopic Operation public virtual DeregisterEventTopicResponse DeregisterEventTopic(DeregisterEventTopicRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterEventTopicResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DeregisterEventTopic operation. ///

/// /// Container for the necessary parameters to execute the DeregisterEventTopic operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeregisterEventTopic /// operation. /// REST API Reference for DeregisterEventTopic Operation public virtual IAsyncResult BeginDeregisterEventTopic(DeregisterEventTopicRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterEventTopicResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DeregisterEventTopic operation. ///

/// /// The IAsyncResult returned by the call to BeginDeregisterEventTopic. /// /// Returns a DeregisterEventTopicResult from DirectoryService. /// REST API Reference for DeregisterEventTopic Operation public virtual DeregisterEventTopicResponse EndDeregisterEventTopic(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeCertificate ///

/// Displays information about the certificate registered for secure LDAP or client certificate /// authentication. ///

/// Container for the necessary parameters to execute the DescribeCertificate service method. /// /// The response from the DescribeCertificate service method, as returned by DirectoryService. /// /// The certificate is not present in the system for describe or deregister activities. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeCertificate Operation public virtual DescribeCertificateResponse DescribeCertificate(DescribeCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeCertificate operation. ///

/// /// Container for the necessary parameters to execute the DescribeCertificate operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeCertificate /// operation. /// REST API Reference for DescribeCertificate Operation public virtual IAsyncResult BeginDescribeCertificate(DescribeCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeCertificate. /// /// Returns a DescribeCertificateResult from DirectoryService. /// REST API Reference for DescribeCertificate Operation public virtual DescribeCertificateResponse EndDescribeCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeClientAuthenticationSettings ///

/// Retrieves information about the type of client authentication for the specified directory, /// if the type is specified. If no type is specified, information about all client authentication /// types that are supported for the specified directory is retrieved. Currently, only /// SmartCard is supported. ///

/// Container for the necessary parameters to execute the DescribeClientAuthenticationSettings service method. /// /// The response from the DescribeClientAuthenticationSettings service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeClientAuthenticationSettings Operation public virtual DescribeClientAuthenticationSettingsResponse DescribeClientAuthenticationSettings(DescribeClientAuthenticationSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClientAuthenticationSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClientAuthenticationSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeClientAuthenticationSettings operation. ///

/// /// Container for the necessary parameters to execute the DescribeClientAuthenticationSettings operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeClientAuthenticationSettings /// operation. /// REST API Reference for DescribeClientAuthenticationSettings Operation public virtual IAsyncResult BeginDescribeClientAuthenticationSettings(DescribeClientAuthenticationSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClientAuthenticationSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClientAuthenticationSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeClientAuthenticationSettings operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeClientAuthenticationSettings. /// /// Returns a DescribeClientAuthenticationSettingsResult from DirectoryService. /// REST API Reference for DescribeClientAuthenticationSettings Operation public virtual DescribeClientAuthenticationSettingsResponse EndDescribeClientAuthenticationSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeConditionalForwarders ///

/// Obtains information about the conditional forwarders for this account. /// /// /// /// If no input parameters are provided for RemoteDomainNames, this request describes /// all conditional forwarders for the specified directory ID. /// ///

/// Container for the necessary parameters to execute the DescribeConditionalForwarders service method. /// /// The response from the DescribeConditionalForwarders service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeConditionalForwarders Operation public virtual DescribeConditionalForwardersResponse DescribeConditionalForwarders(DescribeConditionalForwardersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConditionalForwardersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConditionalForwardersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeConditionalForwarders operation. ///

/// /// Container for the necessary parameters to execute the DescribeConditionalForwarders operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeConditionalForwarders /// operation. /// REST API Reference for DescribeConditionalForwarders Operation public virtual IAsyncResult BeginDescribeConditionalForwarders(DescribeConditionalForwardersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConditionalForwardersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConditionalForwardersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeConditionalForwarders operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeConditionalForwarders. /// /// Returns a DescribeConditionalForwardersResult from DirectoryService. /// REST API Reference for DescribeConditionalForwarders Operation public virtual DescribeConditionalForwardersResponse EndDescribeConditionalForwarders(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeDirectories ///

/// Obtains information about the directories that belong to this account. /// /// /// /// You can retrieve information about specific directories by passing the directory identifiers /// in the DirectoryIds parameter. Otherwise, all directories that belong /// to the current account are returned. /// /// /// /// This operation supports pagination with the use of the NextToken request /// and response parameters. If more results are available, the DescribeDirectoriesResult.NextToken /// member contains a token that you pass in the next call to DescribeDirectories /// to retrieve the next set of items. /// /// /// /// You can also specify a maximum number of return results with the Limit /// parameter. /// ///

/// /// The response from the DescribeDirectories service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DescribeDirectories Operation public virtual DescribeDirectoriesResponse DescribeDirectories() { return DescribeDirectories(new DescribeDirectoriesRequest()); } ///

/// Container for the necessary parameters to execute the DescribeDirectories service method. /// /// The response from the DescribeDirectories service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DescribeDirectories Operation public virtual DescribeDirectoriesResponse DescribeDirectories(DescribeDirectoriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDirectoriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeDirectories operation. ///

/// /// Container for the necessary parameters to execute the DescribeDirectories operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeDirectories /// operation. /// REST API Reference for DescribeDirectories Operation public virtual IAsyncResult BeginDescribeDirectories(DescribeDirectoriesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDirectoriesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeDirectories operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeDirectories. /// /// Returns a DescribeDirectoriesResult from DirectoryService. /// REST API Reference for DescribeDirectories Operation public virtual DescribeDirectoriesResponse EndDescribeDirectories(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeDomainControllers ///

/// Provides information about any domain controllers in your directory. ///

/// Container for the necessary parameters to execute the DescribeDomainControllers service method. /// /// The response from the DescribeDomainControllers service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeDomainControllers Operation public virtual DescribeDomainControllersResponse DescribeDomainControllers(DescribeDomainControllersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDomainControllersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeDomainControllers operation. ///

/// /// Container for the necessary parameters to execute the DescribeDomainControllers operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeDomainControllers /// operation. /// REST API Reference for DescribeDomainControllers Operation public virtual IAsyncResult BeginDescribeDomainControllers(DescribeDomainControllersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDomainControllersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeDomainControllers operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeDomainControllers. /// /// Returns a DescribeDomainControllersResult from DirectoryService. /// REST API Reference for DescribeDomainControllers Operation public virtual DescribeDomainControllersResponse EndDescribeDomainControllers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeEventTopics ///

/// Obtains information about which Amazon SNS topics receive status messages from the /// specified directory. /// /// /// /// If no input parameters are provided, such as DirectoryId or TopicName, this request /// describes all of the associations in the account. /// ///

/// Container for the necessary parameters to execute the DescribeEventTopics service method. /// /// The response from the DescribeEventTopics service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DescribeEventTopics Operation public virtual DescribeEventTopicsResponse DescribeEventTopics(DescribeEventTopicsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventTopicsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventTopicsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeEventTopics operation. ///

/// /// Container for the necessary parameters to execute the DescribeEventTopics operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeEventTopics /// operation. /// REST API Reference for DescribeEventTopics Operation public virtual IAsyncResult BeginDescribeEventTopics(DescribeEventTopicsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventTopicsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventTopicsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeEventTopics operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeEventTopics. /// /// Returns a DescribeEventTopicsResult from DirectoryService. /// REST API Reference for DescribeEventTopics Operation public virtual DescribeEventTopicsResponse EndDescribeEventTopics(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeLDAPSSettings ///

/// Describes the status of LDAP security for the specified directory. ///

/// Container for the necessary parameters to execute the DescribeLDAPSSettings service method. /// /// The response from the DescribeLDAPSSettings service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeLDAPSSettings Operation public virtual DescribeLDAPSSettingsResponse DescribeLDAPSSettings(DescribeLDAPSSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeLDAPSSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeLDAPSSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeLDAPSSettings operation. ///

/// /// Container for the necessary parameters to execute the DescribeLDAPSSettings operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeLDAPSSettings /// operation. /// REST API Reference for DescribeLDAPSSettings Operation public virtual IAsyncResult BeginDescribeLDAPSSettings(DescribeLDAPSSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeLDAPSSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeLDAPSSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeLDAPSSettings operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeLDAPSSettings. /// /// Returns a DescribeLDAPSSettingsResult from DirectoryService. /// REST API Reference for DescribeLDAPSSettings Operation public virtual DescribeLDAPSSettingsResponse EndDescribeLDAPSSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeRegions ///

/// Provides information about the Regions that are configured for multi-Region replication. ///

/// Container for the necessary parameters to execute the DescribeRegions service method. /// /// The response from the DescribeRegions service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeRegions Operation public virtual DescribeRegionsResponse DescribeRegions(DescribeRegionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRegionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeRegions operation. ///

/// /// Container for the necessary parameters to execute the DescribeRegions operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeRegions /// operation. /// REST API Reference for DescribeRegions Operation public virtual IAsyncResult BeginDescribeRegions(DescribeRegionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRegionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeRegions operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeRegions. /// /// Returns a DescribeRegionsResult from DirectoryService. /// REST API Reference for DescribeRegions Operation public virtual DescribeRegionsResponse EndDescribeRegions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeSettings ///

/// Retrieves information about the configurable settings for the specified directory. ///

/// Container for the necessary parameters to execute the DescribeSettings service method. /// /// The response from the DescribeSettings service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeSettings Operation public virtual DescribeSettingsResponse DescribeSettings(DescribeSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeSettings operation. ///

/// /// Container for the necessary parameters to execute the DescribeSettings operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSettings /// operation. /// REST API Reference for DescribeSettings Operation public virtual IAsyncResult BeginDescribeSettings(DescribeSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeSettings operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeSettings. /// /// Returns a DescribeSettingsResult from DirectoryService. /// REST API Reference for DescribeSettings Operation public virtual DescribeSettingsResponse EndDescribeSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeSharedDirectories ///

/// Returns the shared directories in your account. ///

/// Container for the necessary parameters to execute the DescribeSharedDirectories service method. /// /// The response from the DescribeSharedDirectories service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeSharedDirectories Operation public virtual DescribeSharedDirectoriesResponse DescribeSharedDirectories(DescribeSharedDirectoriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSharedDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSharedDirectoriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeSharedDirectories operation. ///

/// /// Container for the necessary parameters to execute the DescribeSharedDirectories operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSharedDirectories /// operation. /// REST API Reference for DescribeSharedDirectories Operation public virtual IAsyncResult BeginDescribeSharedDirectories(DescribeSharedDirectoriesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSharedDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSharedDirectoriesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeSharedDirectories operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeSharedDirectories. /// /// Returns a DescribeSharedDirectoriesResult from DirectoryService. /// REST API Reference for DescribeSharedDirectories Operation public virtual DescribeSharedDirectoriesResponse EndDescribeSharedDirectories(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeSnapshots ///

/// Obtains information about the directory snapshots that belong to this account. /// /// /// /// This operation supports pagination with the use of the NextToken request and /// response parameters. If more results are available, the DescribeSnapshots.NextToken /// member contains a token that you pass in the next call to DescribeSnapshots /// to retrieve the next set of items. /// /// /// /// You can also specify a maximum number of return results with the Limit parameter. /// ///

/// Container for the necessary parameters to execute the DescribeSnapshots service method. /// /// The response from the DescribeSnapshots service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DescribeSnapshots Operation public virtual DescribeSnapshotsResponse DescribeSnapshots(DescribeSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeSnapshots operation. ///

/// /// Container for the necessary parameters to execute the DescribeSnapshots operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeSnapshots /// operation. /// REST API Reference for DescribeSnapshots Operation public virtual IAsyncResult BeginDescribeSnapshots(DescribeSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeSnapshots operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeSnapshots. /// /// Returns a DescribeSnapshotsResult from DirectoryService. /// REST API Reference for DescribeSnapshots Operation public virtual DescribeSnapshotsResponse EndDescribeSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeTrusts ///

/// Obtains information about the trust relationships for this account. /// /// /// /// If no input parameters are provided, such as DirectoryId or TrustIds, this request /// describes all the trust relationships belonging to the account. /// ///

/// Container for the necessary parameters to execute the DescribeTrusts service method. /// /// The response from the DescribeTrusts service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DescribeTrusts Operation public virtual DescribeTrustsResponse DescribeTrusts(DescribeTrustsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTrustsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTrustsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeTrusts operation. ///

/// /// Container for the necessary parameters to execute the DescribeTrusts operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTrusts /// operation. /// REST API Reference for DescribeTrusts Operation public virtual IAsyncResult BeginDescribeTrusts(DescribeTrustsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTrustsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTrustsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeTrusts operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeTrusts. /// /// Returns a DescribeTrustsResult from DirectoryService. /// REST API Reference for DescribeTrusts Operation public virtual DescribeTrustsResponse EndDescribeTrusts(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DescribeUpdateDirectory ///

/// Describes the updates of a directory for a particular update type. ///

/// Container for the necessary parameters to execute the DescribeUpdateDirectory service method. /// /// The response from the DescribeUpdateDirectory service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DescribeUpdateDirectory Operation public virtual DescribeUpdateDirectoryResponse DescribeUpdateDirectory(DescribeUpdateDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUpdateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUpdateDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DescribeUpdateDirectory operation. ///

/// /// Container for the necessary parameters to execute the DescribeUpdateDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeUpdateDirectory /// operation. /// REST API Reference for DescribeUpdateDirectory Operation public virtual IAsyncResult BeginDescribeUpdateDirectory(DescribeUpdateDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUpdateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUpdateDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DescribeUpdateDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginDescribeUpdateDirectory. /// /// Returns a DescribeUpdateDirectoryResult from DirectoryService. /// REST API Reference for DescribeUpdateDirectory Operation public virtual DescribeUpdateDirectoryResponse EndDescribeUpdateDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisableClientAuthentication ///

/// Disables alternative client authentication methods for the specified directory. ///

/// Container for the necessary parameters to execute the DisableClientAuthentication service method. /// /// The response from the DisableClientAuthentication service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// Client authentication is already enabled. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DisableClientAuthentication Operation public virtual DisableClientAuthenticationResponse DisableClientAuthentication(DisableClientAuthenticationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableClientAuthenticationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisableClientAuthentication operation. ///

/// /// Container for the necessary parameters to execute the DisableClientAuthentication operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableClientAuthentication /// operation. /// REST API Reference for DisableClientAuthentication Operation public virtual IAsyncResult BeginDisableClientAuthentication(DisableClientAuthenticationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableClientAuthenticationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisableClientAuthentication operation. ///

/// /// The IAsyncResult returned by the call to BeginDisableClientAuthentication. /// /// Returns a DisableClientAuthenticationResult from DirectoryService. /// REST API Reference for DisableClientAuthentication Operation public virtual DisableClientAuthenticationResponse EndDisableClientAuthentication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisableLDAPS ///

/// Deactivates LDAP secure calls for the specified directory. ///

/// Container for the necessary parameters to execute the DisableLDAPS service method. /// /// The response from the DisableLDAPS service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The LDAP activities could not be performed because they are limited by the LDAPS status. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for DisableLDAPS Operation public virtual DisableLDAPSResponse DisableLDAPS(DisableLDAPSRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableLDAPSResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisableLDAPS operation. ///

/// /// Container for the necessary parameters to execute the DisableLDAPS operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableLDAPS /// operation. /// REST API Reference for DisableLDAPS Operation public virtual IAsyncResult BeginDisableLDAPS(DisableLDAPSRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableLDAPSResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisableLDAPS operation. ///

/// /// The IAsyncResult returned by the call to BeginDisableLDAPS. /// /// Returns a DisableLDAPSResult from DirectoryService. /// REST API Reference for DisableLDAPS Operation public virtual DisableLDAPSResponse EndDisableLDAPS(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisableRadius ///

/// Disables multi-factor authentication (MFA) with the Remote Authentication Dial In /// User Service (RADIUS) server for an AD Connector or Microsoft AD directory. ///

/// Container for the necessary parameters to execute the DisableRadius service method. /// /// The response from the DisableRadius service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DisableRadius Operation public virtual DisableRadiusResponse DisableRadius(DisableRadiusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableRadiusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisableRadius operation. ///

/// /// Container for the necessary parameters to execute the DisableRadius operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableRadius /// operation. /// REST API Reference for DisableRadius Operation public virtual IAsyncResult BeginDisableRadius(DisableRadiusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableRadiusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisableRadius operation. ///

/// /// The IAsyncResult returned by the call to BeginDisableRadius. /// /// Returns a DisableRadiusResult from DirectoryService. /// REST API Reference for DisableRadius Operation public virtual DisableRadiusResponse EndDisableRadius(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DisableSso ///

/// Disables single-sign on for a directory. ///

/// Container for the necessary parameters to execute the DisableSso service method. /// /// The response from the DisableSso service method, as returned by DirectoryService. /// /// An authentication error occurred. /// /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The account does not have sufficient permission to perform the operation. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for DisableSso Operation public virtual DisableSsoResponse DisableSso(DisableSsoRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableSsoResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the DisableSso operation. ///

/// /// Container for the necessary parameters to execute the DisableSso operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDisableSso /// operation. /// REST API Reference for DisableSso Operation public virtual IAsyncResult BeginDisableSso(DisableSsoRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DisableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableSsoResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the DisableSso operation. ///

/// /// The IAsyncResult returned by the call to BeginDisableSso. /// /// Returns a DisableSsoResult from DirectoryService. /// REST API Reference for DisableSso Operation public virtual DisableSsoResponse EndDisableSso(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region EnableClientAuthentication ///

/// Enables alternative client authentication methods for the specified directory. ///

/// Container for the necessary parameters to execute the EnableClientAuthentication service method. /// /// The response from the EnableClientAuthentication service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// Client authentication is already enabled. /// /// /// Client authentication setup could not be completed because at least one valid certificate /// must be registered in the system. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for EnableClientAuthentication Operation public virtual EnableClientAuthenticationResponse EnableClientAuthentication(EnableClientAuthenticationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableClientAuthenticationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the EnableClientAuthentication operation. ///

/// /// Container for the necessary parameters to execute the EnableClientAuthentication operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableClientAuthentication /// operation. /// REST API Reference for EnableClientAuthentication Operation public virtual IAsyncResult BeginEnableClientAuthentication(EnableClientAuthenticationRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = EnableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableClientAuthenticationResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the EnableClientAuthentication operation. ///

/// /// The IAsyncResult returned by the call to BeginEnableClientAuthentication. /// /// Returns a EnableClientAuthenticationResult from DirectoryService. /// REST API Reference for EnableClientAuthentication Operation public virtual EnableClientAuthenticationResponse EndEnableClientAuthentication(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region EnableLDAPS ///

/// Activates the switch for the specific directory to always use LDAP secure calls. ///

/// Container for the necessary parameters to execute the EnableLDAPS service method. /// /// The response from the EnableLDAPS service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The LDAP activities could not be performed because they are limited by the LDAPS status. /// /// /// One or more parameters are not valid. /// /// /// Client authentication setup could not be completed because at least one valid certificate /// must be registered in the system. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for EnableLDAPS Operation public virtual EnableLDAPSResponse EnableLDAPS(EnableLDAPSRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableLDAPSResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the EnableLDAPS operation. ///

/// /// Container for the necessary parameters to execute the EnableLDAPS operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableLDAPS /// operation. /// REST API Reference for EnableLDAPS Operation public virtual IAsyncResult BeginEnableLDAPS(EnableLDAPSRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = EnableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableLDAPSResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the EnableLDAPS operation. ///

/// /// The IAsyncResult returned by the call to BeginEnableLDAPS. /// /// Returns a EnableLDAPSResult from DirectoryService. /// REST API Reference for EnableLDAPS Operation public virtual EnableLDAPSResponse EndEnableLDAPS(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region EnableRadius ///

/// Enables multi-factor authentication (MFA) with the Remote Authentication Dial In User /// Service (RADIUS) server for an AD Connector or Microsoft AD directory. ///

/// Container for the necessary parameters to execute the EnableRadius service method. /// /// The response from the EnableRadius service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity already exists. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for EnableRadius Operation public virtual EnableRadiusResponse EnableRadius(EnableRadiusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableRadiusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the EnableRadius operation. ///

/// /// Container for the necessary parameters to execute the EnableRadius operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableRadius /// operation. /// REST API Reference for EnableRadius Operation public virtual IAsyncResult BeginEnableRadius(EnableRadiusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = EnableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableRadiusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the EnableRadius operation. ///

/// /// The IAsyncResult returned by the call to BeginEnableRadius. /// /// Returns a EnableRadiusResult from DirectoryService. /// REST API Reference for EnableRadius Operation public virtual EnableRadiusResponse EndEnableRadius(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region EnableSso ///

/// Enables single sign-on for a directory. Single sign-on allows users in your directory /// to access certain Amazon Web Services services from a computer joined to the directory /// without having to enter their credentials separately. ///

/// Container for the necessary parameters to execute the EnableSso service method. /// /// The response from the EnableSso service method, as returned by DirectoryService. /// /// An authentication error occurred. /// /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The account does not have sufficient permission to perform the operation. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for EnableSso Operation public virtual EnableSsoResponse EnableSso(EnableSsoRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableSsoResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the EnableSso operation. ///

/// /// Container for the necessary parameters to execute the EnableSso operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndEnableSso /// operation. /// REST API Reference for EnableSso Operation public virtual IAsyncResult BeginEnableSso(EnableSsoRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = EnableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableSsoResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the EnableSso operation. ///

/// /// The IAsyncResult returned by the call to BeginEnableSso. /// /// Returns a EnableSsoResult from DirectoryService. /// REST API Reference for EnableSso Operation public virtual EnableSsoResponse EndEnableSso(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetDirectoryLimits ///

/// Obtains directory limit information for the current Region. ///

/// /// The response from the GetDirectoryLimits service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for GetDirectoryLimits Operation public virtual GetDirectoryLimitsResponse GetDirectoryLimits() { return GetDirectoryLimits(new GetDirectoryLimitsRequest()); } ///

/// Obtains directory limit information for the current Region. ///

/// Container for the necessary parameters to execute the GetDirectoryLimits service method. /// /// The response from the GetDirectoryLimits service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for GetDirectoryLimits Operation public virtual GetDirectoryLimitsResponse GetDirectoryLimits(GetDirectoryLimitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDirectoryLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDirectoryLimitsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetDirectoryLimits operation. ///

/// /// Container for the necessary parameters to execute the GetDirectoryLimits operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetDirectoryLimits /// operation. /// REST API Reference for GetDirectoryLimits Operation public virtual IAsyncResult BeginGetDirectoryLimits(GetDirectoryLimitsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetDirectoryLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDirectoryLimitsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetDirectoryLimits operation. ///

/// /// The IAsyncResult returned by the call to BeginGetDirectoryLimits. /// /// Returns a GetDirectoryLimitsResult from DirectoryService. /// REST API Reference for GetDirectoryLimits Operation public virtual GetDirectoryLimitsResponse EndGetDirectoryLimits(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSnapshotLimits ///

/// Obtains the manual snapshot limits for a directory. ///

/// Container for the necessary parameters to execute the GetSnapshotLimits service method. /// /// The response from the GetSnapshotLimits service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for GetSnapshotLimits Operation public virtual GetSnapshotLimitsResponse GetSnapshotLimits(GetSnapshotLimitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotLimitsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the GetSnapshotLimits operation. ///

/// /// Container for the necessary parameters to execute the GetSnapshotLimits operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetSnapshotLimits /// operation. /// REST API Reference for GetSnapshotLimits Operation public virtual IAsyncResult BeginGetSnapshotLimits(GetSnapshotLimitsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotLimitsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the GetSnapshotLimits operation. ///

/// /// The IAsyncResult returned by the call to BeginGetSnapshotLimits. /// /// Returns a GetSnapshotLimitsResult from DirectoryService. /// REST API Reference for GetSnapshotLimits Operation public virtual GetSnapshotLimitsResponse EndGetSnapshotLimits(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListCertificates ///

/// For the specified directory, lists all the certificates registered for a secure LDAP /// or client certificate authentication. ///

/// Container for the necessary parameters to execute the ListCertificates service method. /// /// The response from the ListCertificates service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for ListCertificates Operation public virtual ListCertificatesResponse ListCertificates(ListCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListCertificates operation. ///

/// /// Container for the necessary parameters to execute the ListCertificates operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListCertificates /// operation. /// REST API Reference for ListCertificates Operation public virtual IAsyncResult BeginListCertificates(ListCertificatesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCertificatesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListCertificates operation. ///

/// /// The IAsyncResult returned by the call to BeginListCertificates. /// /// Returns a ListCertificatesResult from DirectoryService. /// REST API Reference for ListCertificates Operation public virtual ListCertificatesResponse EndListCertificates(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListIpRoutes ///

/// Lists the address blocks that you have added to a directory. ///

/// Container for the necessary parameters to execute the ListIpRoutes service method. /// /// The response from the ListIpRoutes service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for ListIpRoutes Operation public virtual ListIpRoutesResponse ListIpRoutes(ListIpRoutesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListIpRoutesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListIpRoutes operation. ///

/// /// Container for the necessary parameters to execute the ListIpRoutes operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListIpRoutes /// operation. /// REST API Reference for ListIpRoutes Operation public virtual IAsyncResult BeginListIpRoutes(ListIpRoutesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListIpRoutesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListIpRoutes operation. ///

/// /// The IAsyncResult returned by the call to BeginListIpRoutes. /// /// Returns a ListIpRoutesResult from DirectoryService. /// REST API Reference for ListIpRoutes Operation public virtual ListIpRoutesResponse EndListIpRoutes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListLogSubscriptions ///

/// Lists the active log subscriptions for the Amazon Web Services account. ///

/// Container for the necessary parameters to execute the ListLogSubscriptions service method. /// /// The response from the ListLogSubscriptions service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for ListLogSubscriptions Operation public virtual ListLogSubscriptionsResponse ListLogSubscriptions(ListLogSubscriptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLogSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLogSubscriptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListLogSubscriptions operation. ///

/// /// Container for the necessary parameters to execute the ListLogSubscriptions operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListLogSubscriptions /// operation. /// REST API Reference for ListLogSubscriptions Operation public virtual IAsyncResult BeginListLogSubscriptions(ListLogSubscriptionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListLogSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLogSubscriptionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListLogSubscriptions operation. ///

/// /// The IAsyncResult returned by the call to BeginListLogSubscriptions. /// /// Returns a ListLogSubscriptionsResult from DirectoryService. /// REST API Reference for ListLogSubscriptions Operation public virtual ListLogSubscriptionsResponse EndListLogSubscriptions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListSchemaExtensions ///

/// Lists all schema extensions applied to a Microsoft AD Directory. ///

/// Container for the necessary parameters to execute the ListSchemaExtensions service method. /// /// The response from the ListSchemaExtensions service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for ListSchemaExtensions Operation public virtual ListSchemaExtensionsResponse ListSchemaExtensions(ListSchemaExtensionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSchemaExtensionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSchemaExtensionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListSchemaExtensions operation. ///

/// /// Container for the necessary parameters to execute the ListSchemaExtensions operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListSchemaExtensions /// operation. /// REST API Reference for ListSchemaExtensions Operation public virtual IAsyncResult BeginListSchemaExtensions(ListSchemaExtensionsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListSchemaExtensionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSchemaExtensionsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListSchemaExtensions operation. ///

/// /// The IAsyncResult returned by the call to BeginListSchemaExtensions. /// /// Returns a ListSchemaExtensionsResult from DirectoryService. /// REST API Reference for ListSchemaExtensions Operation public virtual ListSchemaExtensionsResponse EndListSchemaExtensions(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// Lists all tags on a directory. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// The NextToken value is not valid. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ListTagsForResource operation. ///

/// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListTagsForResource /// operation. /// REST API Reference for ListTagsForResource Operation public virtual IAsyncResult BeginListTagsForResource(ListTagsForResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ListTagsForResource operation. ///

/// /// The IAsyncResult returned by the call to BeginListTagsForResource. /// /// Returns a ListTagsForResourceResult from DirectoryService. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterCertificate ///

/// Registers a certificate for a secure LDAP or client certificate authentication. ///

/// Container for the necessary parameters to execute the RegisterCertificate service method. /// /// The response from the RegisterCertificate service method, as returned by DirectoryService. /// /// The certificate has already been registered into the system. /// /// /// The certificate could not be added because the certificate limit has been reached. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The certificate PEM that was provided has incorrect encoding. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for RegisterCertificate Operation public virtual RegisterCertificateResponse RegisterCertificate(RegisterCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterCertificate operation. ///

/// /// Container for the necessary parameters to execute the RegisterCertificate operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterCertificate /// operation. /// REST API Reference for RegisterCertificate Operation public virtual IAsyncResult BeginRegisterCertificate(RegisterCertificateRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterCertificateResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterCertificate operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterCertificate. /// /// Returns a RegisterCertificateResult from DirectoryService. /// REST API Reference for RegisterCertificate Operation public virtual RegisterCertificateResponse EndRegisterCertificate(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RegisterEventTopic ///

/// Associates a directory with an Amazon SNS topic. This establishes the directory as /// a publisher to the specified Amazon SNS topic. You can then receive email or text /// (SMS) messages when the status of your directory changes. You get notified if your /// directory goes from an Active status to an Impaired or Inoperable status. You also /// receive a notification when the directory returns to an Active status. ///

/// Container for the necessary parameters to execute the RegisterEventTopic service method. /// /// The response from the RegisterEventTopic service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for RegisterEventTopic Operation public virtual RegisterEventTopicResponse RegisterEventTopic(RegisterEventTopicRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterEventTopicResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RegisterEventTopic operation. ///

/// /// Container for the necessary parameters to execute the RegisterEventTopic operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRegisterEventTopic /// operation. /// REST API Reference for RegisterEventTopic Operation public virtual IAsyncResult BeginRegisterEventTopic(RegisterEventTopicRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterEventTopicResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RegisterEventTopic operation. ///

/// /// The IAsyncResult returned by the call to BeginRegisterEventTopic. /// /// Returns a RegisterEventTopicResult from DirectoryService. /// REST API Reference for RegisterEventTopic Operation public virtual RegisterEventTopicResponse EndRegisterEventTopic(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RejectSharedDirectory ///

/// Rejects a directory sharing request that was sent from the directory owner account. ///

/// Container for the necessary parameters to execute the RejectSharedDirectory service method. /// /// The response from the RejectSharedDirectory service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory has already been shared with this Amazon Web Services account. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for RejectSharedDirectory Operation public virtual RejectSharedDirectoryResponse RejectSharedDirectory(RejectSharedDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectSharedDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RejectSharedDirectory operation. ///

/// /// Container for the necessary parameters to execute the RejectSharedDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRejectSharedDirectory /// operation. /// REST API Reference for RejectSharedDirectory Operation public virtual IAsyncResult BeginRejectSharedDirectory(RejectSharedDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RejectSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectSharedDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RejectSharedDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginRejectSharedDirectory. /// /// Returns a RejectSharedDirectoryResult from DirectoryService. /// REST API Reference for RejectSharedDirectory Operation public virtual RejectSharedDirectoryResponse EndRejectSharedDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RemoveIpRoutes ///

/// Removes IP address blocks from a directory. ///

/// Container for the necessary parameters to execute the RemoveIpRoutes service method. /// /// The response from the RemoveIpRoutes service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for RemoveIpRoutes Operation public virtual RemoveIpRoutesResponse RemoveIpRoutes(RemoveIpRoutesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveIpRoutesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RemoveIpRoutes operation. ///

/// /// Container for the necessary parameters to execute the RemoveIpRoutes operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRemoveIpRoutes /// operation. /// REST API Reference for RemoveIpRoutes Operation public virtual IAsyncResult BeginRemoveIpRoutes(RemoveIpRoutesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveIpRoutesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RemoveIpRoutes operation. ///

/// /// The IAsyncResult returned by the call to BeginRemoveIpRoutes. /// /// Returns a RemoveIpRoutesResult from DirectoryService. /// REST API Reference for RemoveIpRoutes Operation public virtual RemoveIpRoutesResponse EndRemoveIpRoutes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RemoveRegion ///

/// Stops all replication and removes the domain controllers from the specified Region. /// You cannot remove the primary Region with this operation. Instead, use the DeleteDirectory /// API. ///

/// Container for the necessary parameters to execute the RemoveRegion service method. /// /// The response from the RemoveRegion service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The specified directory is unavailable or could not be found. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for RemoveRegion Operation public virtual RemoveRegionResponse RemoveRegion(RemoveRegionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRegionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RemoveRegion operation. ///

/// /// Container for the necessary parameters to execute the RemoveRegion operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRemoveRegion /// operation. /// REST API Reference for RemoveRegion Operation public virtual IAsyncResult BeginRemoveRegion(RemoveRegionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRegionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RemoveRegion operation. ///

/// /// The IAsyncResult returned by the call to BeginRemoveRegion. /// /// Returns a RemoveRegionResult from DirectoryService. /// REST API Reference for RemoveRegion Operation public virtual RemoveRegionResponse EndRemoveRegion(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RemoveTagsFromResource ///

/// Removes tags from a directory. ///

/// Container for the necessary parameters to execute the RemoveTagsFromResource service method. /// /// The response from the RemoveTagsFromResource service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for RemoveTagsFromResource Operation public virtual RemoveTagsFromResourceResponse RemoveTagsFromResource(RemoveTagsFromResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RemoveTagsFromResource operation. ///

/// /// Container for the necessary parameters to execute the RemoveTagsFromResource operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRemoveTagsFromResource /// operation. /// REST API Reference for RemoveTagsFromResource Operation public virtual IAsyncResult BeginRemoveTagsFromResource(RemoveTagsFromResourceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RemoveTagsFromResource operation. ///

/// /// The IAsyncResult returned by the call to BeginRemoveTagsFromResource. /// /// Returns a RemoveTagsFromResourceResult from DirectoryService. /// REST API Reference for RemoveTagsFromResource Operation public virtual RemoveTagsFromResourceResponse EndRemoveTagsFromResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ResetUserPassword ///

/// Resets the password for any user in your Managed Microsoft AD or Simple AD directory. /// /// /// /// You can reset the password for any user in your directory with the following exceptions: /// ///

/// /// For Simple AD, you cannot reset the password for any user that is a member of either /// the Domain Admins or Enterprise Admins group except for the administrator /// user. /// ///
/// /// For Managed Microsoft AD, you can only reset the password for a user that is in an /// OU based off of the NetBIOS name that you typed when you created your directory. For /// example, you cannot reset the password for a user in the Amazon Web Services Reserved /// OU. For more information about the OU structure for an Managed Microsoft AD directory, /// see What /// Gets Created in the Directory Service Administration Guide. /// ///

///

/// Container for the necessary parameters to execute the ResetUserPassword service method. /// /// The response from the ResetUserPassword service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity could not be found. /// /// /// The new password provided by the user does not meet the password complexity requirements /// defined in your directory. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// /// The user provided a username that does not exist in your directory. /// /// REST API Reference for ResetUserPassword Operation public virtual ResetUserPasswordResponse ResetUserPassword(ResetUserPasswordRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetUserPasswordRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetUserPasswordResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ResetUserPassword operation. ///

/// /// Container for the necessary parameters to execute the ResetUserPassword operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndResetUserPassword /// operation. /// REST API Reference for ResetUserPassword Operation public virtual IAsyncResult BeginResetUserPassword(ResetUserPasswordRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ResetUserPasswordRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetUserPasswordResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ResetUserPassword operation. ///

/// /// The IAsyncResult returned by the call to BeginResetUserPassword. /// /// Returns a ResetUserPasswordResult from DirectoryService. /// REST API Reference for ResetUserPassword Operation public virtual ResetUserPasswordResponse EndResetUserPassword(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RestoreFromSnapshot ///

/// Restores a directory using an existing directory snapshot. /// /// /// /// When you restore a directory from a snapshot, any changes made to the directory after /// the snapshot date are overwritten. /// /// /// /// This action returns as soon as the restore operation is initiated. You can monitor /// the progress of the restore operation by calling the DescribeDirectories operation /// with the directory identifier. When the DirectoryDescription.Stage value changes /// to Active, the restore operation is complete. /// ///

/// Container for the necessary parameters to execute the RestoreFromSnapshot service method. /// /// The response from the RestoreFromSnapshot service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for RestoreFromSnapshot Operation public virtual RestoreFromSnapshotResponse RestoreFromSnapshot(RestoreFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the RestoreFromSnapshot operation. ///

/// /// Container for the necessary parameters to execute the RestoreFromSnapshot operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRestoreFromSnapshot /// operation. /// REST API Reference for RestoreFromSnapshot Operation public virtual IAsyncResult BeginRestoreFromSnapshot(RestoreFromSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the RestoreFromSnapshot operation. ///

/// /// The IAsyncResult returned by the call to BeginRestoreFromSnapshot. /// /// Returns a RestoreFromSnapshotResult from DirectoryService. /// REST API Reference for RestoreFromSnapshot Operation public virtual RestoreFromSnapshotResponse EndRestoreFromSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ShareDirectory ///

/// Shares a specified directory (DirectoryId) in your Amazon Web Services /// account (directory owner) with another Amazon Web Services account (directory consumer). /// With this operation you can use your directory from any Amazon Web Services account /// and from any Amazon VPC within an Amazon Web Services Region. /// /// /// /// When you share your Managed Microsoft AD directory, Directory Service creates a shared /// directory in the directory consumer account. This shared directory contains the metadata /// to provide access to the directory within the directory owner account. The shared /// directory is visible in all VPCs in the directory consumer account. /// /// /// /// The ShareMethod parameter determines whether the specified directory /// can be shared between Amazon Web Services accounts inside the same Amazon Web Services /// organization (ORGANIZATIONS). It also determines whether you can share /// the directory with any other Amazon Web Services account either inside or outside /// of the organization (HANDSHAKE). /// /// /// /// The ShareNotes parameter is only used when HANDSHAKE is /// called, which sends a directory sharing request to the directory consumer. /// ///

/// Container for the necessary parameters to execute the ShareDirectory service method. /// /// The response from the ShareDirectory service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory has already been shared with this Amazon Web Services account. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// The specified shared target is not valid. /// /// /// Exception encountered while trying to access your Amazon Web Services organization. /// /// /// An exception has occurred in Directory Service. /// /// /// The maximum number of Amazon Web Services accounts that you can share with this directory /// has been reached. /// /// /// The operation is not supported. /// /// REST API Reference for ShareDirectory Operation public virtual ShareDirectoryResponse ShareDirectory(ShareDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ShareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ShareDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the ShareDirectory operation. ///

/// /// Container for the necessary parameters to execute the ShareDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndShareDirectory /// operation. /// REST API Reference for ShareDirectory Operation public virtual IAsyncResult BeginShareDirectory(ShareDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ShareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ShareDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the ShareDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginShareDirectory. /// /// Returns a ShareDirectoryResult from DirectoryService. /// REST API Reference for ShareDirectory Operation public virtual ShareDirectoryResponse EndShareDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region StartSchemaExtension ///

/// Applies a schema extension to a Microsoft AD directory. ///

/// Container for the necessary parameters to execute the StartSchemaExtension service method. /// /// The response from the StartSchemaExtension service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The maximum number of manual snapshots for the directory has been reached. You can /// use the GetSnapshotLimits operation to determine the snapshot limits for a /// directory. /// /// REST API Reference for StartSchemaExtension Operation public virtual StartSchemaExtensionResponse StartSchemaExtension(StartSchemaExtensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSchemaExtensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the StartSchemaExtension operation. ///

/// /// Container for the necessary parameters to execute the StartSchemaExtension operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndStartSchemaExtension /// operation. /// REST API Reference for StartSchemaExtension Operation public virtual IAsyncResult BeginStartSchemaExtension(StartSchemaExtensionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = StartSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSchemaExtensionResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the StartSchemaExtension operation. ///

/// /// The IAsyncResult returned by the call to BeginStartSchemaExtension. /// /// Returns a StartSchemaExtensionResult from DirectoryService. /// REST API Reference for StartSchemaExtension Operation public virtual StartSchemaExtensionResponse EndStartSchemaExtension(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UnshareDirectory ///

/// Stops the directory sharing between the directory owner and consumer accounts. ///

/// Container for the necessary parameters to execute the UnshareDirectory service method. /// /// The response from the UnshareDirectory service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory has not been shared with this Amazon Web Services account. /// /// /// The specified entity could not be found. /// /// /// The specified shared target is not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for UnshareDirectory Operation public virtual UnshareDirectoryResponse UnshareDirectory(UnshareDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UnshareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = UnshareDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UnshareDirectory operation. ///

/// /// Container for the necessary parameters to execute the UnshareDirectory operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUnshareDirectory /// operation. /// REST API Reference for UnshareDirectory Operation public virtual IAsyncResult BeginUnshareDirectory(UnshareDirectoryRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UnshareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = UnshareDirectoryResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UnshareDirectory operation. ///

/// /// The IAsyncResult returned by the call to BeginUnshareDirectory. /// /// Returns a UnshareDirectoryResult from DirectoryService. /// REST API Reference for UnshareDirectory Operation public virtual UnshareDirectoryResponse EndUnshareDirectory(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateConditionalForwarder ///

/// Updates a conditional forwarder that has been set up for your Amazon Web Services /// directory. ///

/// Container for the necessary parameters to execute the UpdateConditionalForwarder service method. /// /// The response from the UpdateConditionalForwarder service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for UpdateConditionalForwarder Operation public virtual UpdateConditionalForwarderResponse UpdateConditionalForwarder(UpdateConditionalForwarderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConditionalForwarderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateConditionalForwarder operation. ///

/// /// Container for the necessary parameters to execute the UpdateConditionalForwarder operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateConditionalForwarder /// operation. /// REST API Reference for UpdateConditionalForwarder Operation public virtual IAsyncResult BeginUpdateConditionalForwarder(UpdateConditionalForwarderRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConditionalForwarderResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateConditionalForwarder operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateConditionalForwarder. /// /// Returns a UpdateConditionalForwarderResult from DirectoryService. /// REST API Reference for UpdateConditionalForwarder Operation public virtual UpdateConditionalForwarderResponse EndUpdateConditionalForwarder(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateDirectorySetup ///

/// Updates the directory for a particular update type. ///

/// Container for the necessary parameters to execute the UpdateDirectorySetup service method. /// /// The response from the UpdateDirectorySetup service method, as returned by DirectoryService. /// /// Client authentication is not available in this region at this time. /// /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The directory is already updated to desired update type settings. /// /// /// The specified directory is unavailable or could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The maximum number of manual snapshots for the directory has been reached. You can /// use the GetSnapshotLimits operation to determine the snapshot limits for a /// directory. /// /// /// The operation is not supported. /// /// REST API Reference for UpdateDirectorySetup Operation public virtual UpdateDirectorySetupResponse UpdateDirectorySetup(UpdateDirectorySetupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDirectorySetupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDirectorySetupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateDirectorySetup operation. ///

/// /// Container for the necessary parameters to execute the UpdateDirectorySetup operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateDirectorySetup /// operation. /// REST API Reference for UpdateDirectorySetup Operation public virtual IAsyncResult BeginUpdateDirectorySetup(UpdateDirectorySetupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDirectorySetupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDirectorySetupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateDirectorySetup operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateDirectorySetup. /// /// Returns a UpdateDirectorySetupResult from DirectoryService. /// REST API Reference for UpdateDirectorySetup Operation public virtual UpdateDirectorySetupResponse EndUpdateDirectorySetup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateNumberOfDomainControllers ///

/// Adds or removes domain controllers to or from the directory. Based on the difference /// between current value and new value (provided through this API call), domain controllers /// will be added or removed. It may take up to 45 minutes for any new domain controllers /// to become fully active once the requested number of domain controllers is updated. /// During this time, you cannot make another update request. ///

/// Container for the necessary parameters to execute the UpdateNumberOfDomainControllers service method. /// /// The response from the UpdateNumberOfDomainControllers service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The maximum allowed number of domain controllers per directory was exceeded. The default /// limit per directory is 20 domain controllers. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for UpdateNumberOfDomainControllers Operation public virtual UpdateNumberOfDomainControllersResponse UpdateNumberOfDomainControllers(UpdateNumberOfDomainControllersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNumberOfDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNumberOfDomainControllersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateNumberOfDomainControllers operation. ///

/// /// Container for the necessary parameters to execute the UpdateNumberOfDomainControllers operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateNumberOfDomainControllers /// operation. /// REST API Reference for UpdateNumberOfDomainControllers Operation public virtual IAsyncResult BeginUpdateNumberOfDomainControllers(UpdateNumberOfDomainControllersRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNumberOfDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNumberOfDomainControllersResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateNumberOfDomainControllers operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateNumberOfDomainControllers. /// /// Returns a UpdateNumberOfDomainControllersResult from DirectoryService. /// REST API Reference for UpdateNumberOfDomainControllers Operation public virtual UpdateNumberOfDomainControllersResponse EndUpdateNumberOfDomainControllers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateRadius ///

/// Updates the Remote Authentication Dial In User Service (RADIUS) server information /// for an AD Connector or Microsoft AD directory. ///

/// Container for the necessary parameters to execute the UpdateRadius service method. /// /// The response from the UpdateRadius service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for UpdateRadius Operation public virtual UpdateRadiusResponse UpdateRadius(UpdateRadiusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRadiusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateRadius operation. ///

/// /// Container for the necessary parameters to execute the UpdateRadius operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateRadius /// operation. /// REST API Reference for UpdateRadius Operation public virtual IAsyncResult BeginUpdateRadius(UpdateRadiusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRadiusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateRadius operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateRadius. /// /// Returns a UpdateRadiusResult from DirectoryService. /// REST API Reference for UpdateRadius Operation public virtual UpdateRadiusResponse EndUpdateRadius(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateSettings ///

/// Updates the configurable settings for the specified directory. ///

/// Container for the necessary parameters to execute the UpdateSettings service method. /// /// The response from the UpdateSettings service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified directory does not exist in the system. /// /// /// The specified directory is unavailable or could not be found. /// /// /// The specified directory setting is not compatible with other settings. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// /// The specified directory setting is not supported. /// /// REST API Reference for UpdateSettings Operation public virtual UpdateSettingsResponse UpdateSettings(UpdateSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateSettings operation. ///

/// /// Container for the necessary parameters to execute the UpdateSettings operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateSettings /// operation. /// REST API Reference for UpdateSettings Operation public virtual IAsyncResult BeginUpdateSettings(UpdateSettingsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSettingsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateSettings operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateSettings. /// /// Returns a UpdateSettingsResult from DirectoryService. /// REST API Reference for UpdateSettings Operation public virtual UpdateSettingsResponse EndUpdateSettings(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateTrust ///

/// Updates the trust that has been set up between your Managed Microsoft AD directory /// and an self-managed Active Directory. ///

/// Container for the necessary parameters to execute the UpdateTrust service method. /// /// The response from the UpdateTrust service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// REST API Reference for UpdateTrust Operation public virtual UpdateTrustResponse UpdateTrust(UpdateTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the UpdateTrust operation. ///

/// /// Container for the necessary parameters to execute the UpdateTrust operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndUpdateTrust /// operation. /// REST API Reference for UpdateTrust Operation public virtual IAsyncResult BeginUpdateTrust(UpdateTrustRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTrustResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the UpdateTrust operation. ///

/// /// The IAsyncResult returned by the call to BeginUpdateTrust. /// /// Returns a UpdateTrustResult from DirectoryService. /// REST API Reference for UpdateTrust Operation public virtual UpdateTrustResponse EndUpdateTrust(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region VerifyTrust ///

/// Directory Service for Microsoft Active Directory allows you to configure and verify /// trust relationships. /// /// /// /// This action verifies a trust relationship between your Managed Microsoft AD directory /// and an external domain. /// ///

/// Container for the necessary parameters to execute the VerifyTrust service method. /// /// The response from the VerifyTrust service method, as returned by DirectoryService. /// /// A client exception has occurred. /// /// /// The specified entity could not be found. /// /// /// One or more parameters are not valid. /// /// /// An exception has occurred in Directory Service. /// /// /// The operation is not supported. /// /// REST API Reference for VerifyTrust Operation public virtual VerifyTrustResponse VerifyTrust(VerifyTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = VerifyTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = VerifyTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Initiates the asynchronous execution of the VerifyTrust operation. ///

/// /// Container for the necessary parameters to execute the VerifyTrust operation on AmazonDirectoryServiceClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndVerifyTrust /// operation. /// REST API Reference for VerifyTrust Operation public virtual IAsyncResult BeginVerifyTrust(VerifyTrustRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = VerifyTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = VerifyTrustResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } ///

/// Finishes the asynchronous execution of the VerifyTrust operation. ///

/// /// The IAsyncResult returned by the call to BeginVerifyTrust. /// /// Returns a VerifyTrustResult from DirectoryService. /// REST API Reference for VerifyTrust Operation public virtual VerifyTrustResponse EndVerifyTrust(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }