/* * 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.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; 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(); #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 #if 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 Overrides ///

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

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

/// Customizes the runtime pipeline. ///

/// Runtime pipeline for the current client. 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 internal virtual AcceptSharedDirectoryResponse AcceptSharedDirectory(AcceptSharedDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptSharedDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the AcceptSharedDirectory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task AcceptSharedDirectoryAsync(AcceptSharedDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AcceptSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = AcceptSharedDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddIpRoutes internal virtual AddIpRoutesResponse AddIpRoutes(AddIpRoutesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = AddIpRoutesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task AddIpRoutesAsync(AddIpRoutesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = AddIpRoutesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddRegion internal virtual AddRegionResponse AddRegion(AddRegionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRegionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the AddRegion service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task AddRegionAsync(AddRegionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = AddRegionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region AddTagsToResource internal virtual AddTagsToResourceResponse AddTagsToResource(AddTagsToResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task AddTagsToResourceAsync(AddTagsToResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = AddTagsToResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = AddTagsToResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CancelSchemaExtension internal virtual CancelSchemaExtensionResponse CancelSchemaExtension(CancelSchemaExtensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSchemaExtensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CancelSchemaExtensionAsync(CancelSchemaExtensionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CancelSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = CancelSchemaExtensionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ConnectDirectory internal virtual ConnectDirectoryResponse ConnectDirectory(ConnectDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ConnectDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ConnectDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ConnectDirectoryAsync(ConnectDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ConnectDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ConnectDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateAlias internal virtual CreateAliasResponse CreateAlias(CreateAliasRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAliasResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateAliasAsync(CreateAliasRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateAliasRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateAliasResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateComputer internal virtual CreateComputerResponse CreateComputer(CreateComputerRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateComputerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateComputerResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the CreateComputer service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateComputerAsync(CreateComputerRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateComputerRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateComputerResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateConditionalForwarder internal virtual CreateConditionalForwarderResponse CreateConditionalForwarder(CreateConditionalForwarderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConditionalForwarderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateConditionalForwarderAsync(CreateConditionalForwarderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateConditionalForwarderResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateDirectory internal virtual CreateDirectoryResponse CreateDirectory(CreateDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateDirectoryAsync(CreateDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateLogSubscription internal virtual CreateLogSubscriptionResponse CreateLogSubscription(CreateLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateLogSubscriptionAsync(CreateLogSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateLogSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateMicrosoftAD internal virtual CreateMicrosoftADResponse CreateMicrosoftAD(CreateMicrosoftADRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMicrosoftADRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMicrosoftADResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateMicrosoftADAsync(CreateMicrosoftADRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateMicrosoftADRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateMicrosoftADResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateSnapshot internal virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateSnapshotAsync(CreateSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateTrust internal virtual CreateTrustResponse CreateTrust(CreateTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateTrustAsync(CreateTrustRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateTrustResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteConditionalForwarder internal virtual DeleteConditionalForwarderResponse DeleteConditionalForwarder(DeleteConditionalForwarderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConditionalForwarderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteConditionalForwarderAsync(DeleteConditionalForwarderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteConditionalForwarderResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteDirectory internal virtual DeleteDirectoryResponse DeleteDirectory(DeleteDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteDirectoryAsync(DeleteDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteLogSubscription internal virtual DeleteLogSubscriptionResponse DeleteLogSubscription(DeleteLogSubscriptionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLogSubscriptionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeleteLogSubscription service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteLogSubscriptionAsync(DeleteLogSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteLogSubscriptionRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteLogSubscriptionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteSnapshot internal virtual DeleteSnapshotResponse DeleteSnapshot(DeleteSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// Deletes a directory snapshot. ///

/// Container for the necessary parameters to execute the DeleteSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteSnapshotAsync(DeleteSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteTrust internal virtual DeleteTrustResponse DeleteTrust(DeleteTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteTrustAsync(DeleteTrustRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteTrustResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterCertificate internal virtual DeregisterCertificateResponse DeregisterCertificate(DeregisterCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeregisterCertificateAsync(DeregisterCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeregisterEventTopic internal virtual DeregisterEventTopicResponse DeregisterEventTopic(DeregisterEventTopicRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterEventTopicResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DeregisterEventTopic service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeregisterEventTopicAsync(DeregisterEventTopicRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeregisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = DeregisterEventTopicResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeCertificate internal virtual DescribeCertificateResponse DescribeCertificate(DescribeCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeCertificateAsync(DescribeCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeClientAuthenticationSettings internal virtual DescribeClientAuthenticationSettingsResponse DescribeClientAuthenticationSettings(DescribeClientAuthenticationSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClientAuthenticationSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClientAuthenticationSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeClientAuthenticationSettingsAsync(DescribeClientAuthenticationSettingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeClientAuthenticationSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeClientAuthenticationSettingsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeConditionalForwarders internal virtual DescribeConditionalForwardersResponse DescribeConditionalForwarders(DescribeConditionalForwardersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConditionalForwardersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConditionalForwardersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeConditionalForwardersAsync(DescribeConditionalForwardersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeConditionalForwardersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeConditionalForwardersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDirectories internal virtual DescribeDirectoriesResponse DescribeDirectories() { return DescribeDirectories(new DescribeDirectoriesRequest()); } internal virtual DescribeDirectoriesResponse DescribeDirectories(DescribeDirectoriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDirectoriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// ///

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeDirectoriesAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return DescribeDirectoriesAsync(new DescribeDirectoriesRequest(), cancellationToken); } ///

/// Container for the necessary parameters to execute the DescribeDirectories service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeDirectoriesAsync(DescribeDirectoriesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDirectoriesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeDomainControllers internal virtual DescribeDomainControllersResponse DescribeDomainControllers(DescribeDomainControllersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDomainControllersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeDomainControllers service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeDomainControllersAsync(DescribeDomainControllersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeDomainControllersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeEventTopics internal virtual DescribeEventTopicsResponse DescribeEventTopics(DescribeEventTopicsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventTopicsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventTopicsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeEventTopicsAsync(DescribeEventTopicsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeEventTopicsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeEventTopicsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeLDAPSSettings internal virtual DescribeLDAPSSettingsResponse DescribeLDAPSSettings(DescribeLDAPSSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeLDAPSSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeLDAPSSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeLDAPSSettings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeLDAPSSettingsAsync(DescribeLDAPSSettingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeLDAPSSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeLDAPSSettingsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeRegions internal virtual DescribeRegionsResponse DescribeRegions(DescribeRegionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRegionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeRegions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeRegionsAsync(DescribeRegionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeRegionsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeRegionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSettings internal virtual DescribeSettingsResponse DescribeSettings(DescribeSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeSettings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeSettingsAsync(DescribeSettingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSettingsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSharedDirectories internal virtual DescribeSharedDirectoriesResponse DescribeSharedDirectories(DescribeSharedDirectoriesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSharedDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSharedDirectoriesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeSharedDirectories service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeSharedDirectoriesAsync(DescribeSharedDirectoriesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSharedDirectoriesRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSharedDirectoriesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeSnapshots internal virtual DescribeSnapshotsResponse DescribeSnapshots(DescribeSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeSnapshotsAsync(DescribeSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeTrusts internal virtual DescribeTrustsResponse DescribeTrusts(DescribeTrustsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTrustsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTrustsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeTrustsAsync(DescribeTrustsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeTrustsRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeTrustsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DescribeUpdateDirectory internal virtual DescribeUpdateDirectoryResponse DescribeUpdateDirectory(DescribeUpdateDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUpdateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUpdateDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DescribeUpdateDirectory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DescribeUpdateDirectoryAsync(DescribeUpdateDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DescribeUpdateDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = DescribeUpdateDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisableClientAuthentication internal virtual DisableClientAuthenticationResponse DisableClientAuthentication(DisableClientAuthenticationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableClientAuthenticationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DisableClientAuthentication service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DisableClientAuthenticationAsync(DisableClientAuthenticationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableClientAuthenticationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisableLDAPS internal virtual DisableLDAPSResponse DisableLDAPS(DisableLDAPSRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableLDAPSResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DisableLDAPS service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DisableLDAPSAsync(DisableLDAPSRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableLDAPSResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisableRadius internal virtual DisableRadiusResponse DisableRadius(DisableRadiusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableRadiusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DisableRadiusAsync(DisableRadiusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableRadiusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DisableSso internal virtual DisableSsoResponse DisableSso(DisableSsoRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DisableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableSsoResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the DisableSso service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DisableSsoAsync(DisableSsoRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DisableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = DisableSsoResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region EnableClientAuthentication internal virtual EnableClientAuthenticationResponse EnableClientAuthentication(EnableClientAuthenticationRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableClientAuthenticationResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the EnableClientAuthentication service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task EnableClientAuthenticationAsync(EnableClientAuthenticationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = EnableClientAuthenticationRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableClientAuthenticationResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region EnableLDAPS internal virtual EnableLDAPSResponse EnableLDAPS(EnableLDAPSRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableLDAPSResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the EnableLDAPS service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task EnableLDAPSAsync(EnableLDAPSRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = EnableLDAPSRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableLDAPSResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region EnableRadius internal virtual EnableRadiusResponse EnableRadius(EnableRadiusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableRadiusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task EnableRadiusAsync(EnableRadiusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = EnableRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableRadiusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region EnableSso internal virtual EnableSsoResponse EnableSso(EnableSsoRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = EnableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableSsoResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task EnableSsoAsync(EnableSsoRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = EnableSsoRequestMarshaller.Instance; options.ResponseUnmarshaller = EnableSsoResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetDirectoryLimits internal virtual GetDirectoryLimitsResponse GetDirectoryLimits() { return GetDirectoryLimits(new GetDirectoryLimitsRequest()); } internal virtual GetDirectoryLimitsResponse GetDirectoryLimits(GetDirectoryLimitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetDirectoryLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDirectoryLimitsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetDirectoryLimitsAsync(System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { return GetDirectoryLimitsAsync(new GetDirectoryLimitsRequest(), cancellationToken); } ///

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

/// Container for the necessary parameters to execute the GetDirectoryLimits service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetDirectoryLimitsAsync(GetDirectoryLimitsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetDirectoryLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetDirectoryLimitsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetSnapshotLimits internal virtual GetSnapshotLimitsResponse GetSnapshotLimits(GetSnapshotLimitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotLimitsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the GetSnapshotLimits service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetSnapshotLimitsAsync(GetSnapshotLimitsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotLimitsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListCertificates internal virtual ListCertificatesResponse ListCertificates(ListCertificatesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCertificatesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListCertificatesAsync(ListCertificatesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListCertificatesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListCertificatesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListIpRoutes internal virtual ListIpRoutesResponse ListIpRoutes(ListIpRoutesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListIpRoutesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListIpRoutes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListIpRoutesAsync(ListIpRoutesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListIpRoutesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListLogSubscriptions internal virtual ListLogSubscriptionsResponse ListLogSubscriptions(ListLogSubscriptionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListLogSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLogSubscriptionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListLogSubscriptions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListLogSubscriptionsAsync(ListLogSubscriptionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListLogSubscriptionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListLogSubscriptionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListSchemaExtensions internal virtual ListSchemaExtensionsResponse ListSchemaExtensions(ListSchemaExtensionsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSchemaExtensionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSchemaExtensionsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListSchemaExtensions service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListSchemaExtensionsAsync(ListSchemaExtensionsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListSchemaExtensionsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSchemaExtensionsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTagsForResource internal virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterCertificate internal virtual RegisterCertificateResponse RegisterCertificate(RegisterCertificateRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterCertificateResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the RegisterCertificate service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RegisterCertificateAsync(RegisterCertificateRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterCertificateRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterCertificateResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RegisterEventTopic internal virtual RegisterEventTopicResponse RegisterEventTopic(RegisterEventTopicRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterEventTopicResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RegisterEventTopicAsync(RegisterEventTopicRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RegisterEventTopicRequestMarshaller.Instance; options.ResponseUnmarshaller = RegisterEventTopicResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RejectSharedDirectory internal virtual RejectSharedDirectoryResponse RejectSharedDirectory(RejectSharedDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RejectSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectSharedDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the RejectSharedDirectory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RejectSharedDirectoryAsync(RejectSharedDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RejectSharedDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = RejectSharedDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveIpRoutes internal virtual RemoveIpRoutesResponse RemoveIpRoutes(RemoveIpRoutesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveIpRoutesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the RemoveIpRoutes service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RemoveIpRoutesAsync(RemoveIpRoutesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveIpRoutesRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveIpRoutesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveRegion internal virtual RemoveRegionResponse RemoveRegion(RemoveRegionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRegionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RemoveRegionAsync(RemoveRegionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveRegionRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveRegionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RemoveTagsFromResource internal virtual RemoveTagsFromResourceResponse RemoveTagsFromResource(RemoveTagsFromResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the RemoveTagsFromResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RemoveTagsFromResourceAsync(RemoveTagsFromResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RemoveTagsFromResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = RemoveTagsFromResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ResetUserPassword internal virtual ResetUserPasswordResponse ResetUserPassword(ResetUserPasswordRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ResetUserPasswordRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetUserPasswordResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ResetUserPasswordAsync(ResetUserPasswordRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ResetUserPasswordRequestMarshaller.Instance; options.ResponseUnmarshaller = ResetUserPasswordResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreFromSnapshot internal virtual RestoreFromSnapshotResponse RestoreFromSnapshot(RestoreFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RestoreFromSnapshotAsync(RestoreFromSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ShareDirectory internal virtual ShareDirectoryResponse ShareDirectory(ShareDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ShareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ShareDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ShareDirectoryAsync(ShareDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ShareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = ShareDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region StartSchemaExtension internal virtual StartSchemaExtensionResponse StartSchemaExtension(StartSchemaExtensionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSchemaExtensionResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the StartSchemaExtension service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task StartSchemaExtensionAsync(StartSchemaExtensionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = StartSchemaExtensionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartSchemaExtensionResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UnshareDirectory internal virtual UnshareDirectoryResponse UnshareDirectory(UnshareDirectoryRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UnshareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = UnshareDirectoryResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the UnshareDirectory service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UnshareDirectoryAsync(UnshareDirectoryRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UnshareDirectoryRequestMarshaller.Instance; options.ResponseUnmarshaller = UnshareDirectoryResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateConditionalForwarder internal virtual UpdateConditionalForwarderResponse UpdateConditionalForwarder(UpdateConditionalForwarderRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConditionalForwarderResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateConditionalForwarderAsync(UpdateConditionalForwarderRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateConditionalForwarderRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateConditionalForwarderResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateDirectorySetup internal virtual UpdateDirectorySetupResponse UpdateDirectorySetup(UpdateDirectorySetupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDirectorySetupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDirectorySetupResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the UpdateDirectorySetup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateDirectorySetupAsync(UpdateDirectorySetupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateDirectorySetupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateDirectorySetupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateNumberOfDomainControllers internal virtual UpdateNumberOfDomainControllersResponse UpdateNumberOfDomainControllers(UpdateNumberOfDomainControllersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNumberOfDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNumberOfDomainControllersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateNumberOfDomainControllersAsync(UpdateNumberOfDomainControllersRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNumberOfDomainControllersRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNumberOfDomainControllersResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateRadius internal virtual UpdateRadiusResponse UpdateRadius(UpdateRadiusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRadiusResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateRadiusAsync(UpdateRadiusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateRadiusRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateRadiusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateSettings internal virtual UpdateSettingsResponse UpdateSettings(UpdateSettingsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSettingsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

/// Container for the necessary parameters to execute the UpdateSettings service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateSettingsAsync(UpdateSettingsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSettingsRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSettingsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateTrust internal virtual UpdateTrustResponse UpdateTrust(UpdateTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateTrustAsync(UpdateTrustRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateTrustResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region VerifyTrust internal virtual VerifyTrustResponse VerifyTrust(VerifyTrustRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = VerifyTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = VerifyTrustResponseUnmarshaller.Instance; return Invoke(request, options); } ///

/// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task VerifyTrustAsync(VerifyTrustRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = VerifyTrustRequestMarshaller.Instance; options.ResponseUnmarshaller = VerifyTrustResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion } }