/* * 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 finspace-2021-03-12.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.Finspace.Model; using Amazon.Finspace.Model.Internal.MarshallTransformations; using Amazon.Finspace.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.Finspace { ///

/// Implementation for accessing Finspace /// /// The FinSpace management service provides the APIs for managing FinSpace environments. ///

public partial class AmazonFinspaceClient : AmazonServiceClient, IAmazonFinspace { private static IServiceMetadata serviceMetadata = new AmazonFinspaceMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IFinspacePaginatorFactory _paginators; ///

/// Paginators for the service ///

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

/// Constructs AmazonFinspaceClient 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 AmazonFinspaceClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonFinspaceConfig()) { } ///


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

/// ///

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


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

/// ///

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

/// Constructs AmazonFinspaceClient with AWS Credentials ///

/// AWS Credentials public AmazonFinspaceClient(AWSCredentials credentials) : this(credentials, new AmazonFinspaceConfig()) { } ///

/// Constructs AmazonFinspaceClient with AWS Credentials ///

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

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

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

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

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

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

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

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

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

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

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

/// Constructs AmazonFinspaceClient 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 AmazonFinspaceClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonFinspaceConfig{RegionEndpoint = region}) { } ///

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

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

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

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

/// Customize the pipeline ///

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

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

/// Create a new FinSpace environment. ///

/// Container for the necessary parameters to execute the CreateEnvironment service method. /// /// The response from the CreateEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// You have exceeded your service quota. To perform the requested action, remove some /// of the relevant resources, or use Service Quotas to request a service quota increase. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateEnvironment Operation public virtual CreateEnvironmentResponse CreateEnvironment(CreateEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateEnvironment. /// /// Returns a CreateEnvironmentResult from Finspace. /// REST API Reference for CreateEnvironment Operation public virtual CreateEnvironmentResponse EndCreateEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateKxChangeset ///

/// Creates a changeset for a kdb database. A changeset allows you to add and delete /// existing files by using an ordered list of change requests. ///

/// Container for the necessary parameters to execute the CreateKxChangeset service method. /// /// The response from the CreateKxChangeset service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateKxChangeset Operation public virtual CreateKxChangesetResponse CreateKxChangeset(CreateKxChangesetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKxChangesetRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKxChangesetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateKxChangeset. /// /// Returns a CreateKxChangesetResult from Finspace. /// REST API Reference for CreateKxChangeset Operation public virtual CreateKxChangesetResponse EndCreateKxChangeset(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateKxCluster ///

/// Creates a new kdb cluster. ///

/// Container for the necessary parameters to execute the CreateKxCluster service method. /// /// The response from the CreateKxCluster service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateKxCluster Operation public virtual CreateKxClusterResponse CreateKxCluster(CreateKxClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKxClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKxClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateKxCluster. /// /// Returns a CreateKxClusterResult from Finspace. /// REST API Reference for CreateKxCluster Operation public virtual CreateKxClusterResponse EndCreateKxCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateKxDatabase ///

/// Creates a new kdb database in the environment. ///

/// Container for the necessary parameters to execute the CreateKxDatabase service method. /// /// The response from the CreateKxDatabase service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// The specified resource group already exists. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateKxDatabase Operation public virtual CreateKxDatabaseResponse CreateKxDatabase(CreateKxDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKxDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKxDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateKxDatabase. /// /// Returns a CreateKxDatabaseResult from Finspace. /// REST API Reference for CreateKxDatabase Operation public virtual CreateKxDatabaseResponse EndCreateKxDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateKxEnvironment ///

/// Creates a managed kdb environment for the account. ///

/// Container for the necessary parameters to execute the CreateKxEnvironment service method. /// /// The response from the CreateKxEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// You have exceeded your service quota. To perform the requested action, remove some /// of the relevant resources, or use Service Quotas to request a service quota increase. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateKxEnvironment Operation public virtual CreateKxEnvironmentResponse CreateKxEnvironment(CreateKxEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKxEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKxEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateKxEnvironment. /// /// Returns a CreateKxEnvironmentResult from Finspace. /// REST API Reference for CreateKxEnvironment Operation public virtual CreateKxEnvironmentResponse EndCreateKxEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateKxUser ///

/// Creates a user in FinSpace kdb environment with an associated IAM role. ///

/// Container for the necessary parameters to execute the CreateKxUser service method. /// /// The response from the CreateKxUser service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// The specified resource group already exists. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateKxUser Operation public virtual CreateKxUserResponse CreateKxUser(CreateKxUserRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateKxUserRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateKxUserResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginCreateKxUser. /// /// Returns a CreateKxUserResult from Finspace. /// REST API Reference for CreateKxUser Operation public virtual CreateKxUserResponse EndCreateKxUser(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteEnvironment ///

/// Delete an FinSpace environment. ///

/// Container for the necessary parameters to execute the DeleteEnvironment service method. /// /// The response from the DeleteEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteEnvironment Operation public virtual DeleteEnvironmentResponse DeleteEnvironment(DeleteEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteEnvironment. /// /// Returns a DeleteEnvironmentResult from Finspace. /// REST API Reference for DeleteEnvironment Operation public virtual DeleteEnvironmentResponse EndDeleteEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteKxCluster ///

/// Deletes a kdb cluster. ///

/// Container for the necessary parameters to execute the DeleteKxCluster service method. /// /// The response from the DeleteKxCluster service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteKxCluster Operation public virtual DeleteKxClusterResponse DeleteKxCluster(DeleteKxClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKxClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKxClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteKxCluster. /// /// Returns a DeleteKxClusterResult from Finspace. /// REST API Reference for DeleteKxCluster Operation public virtual DeleteKxClusterResponse EndDeleteKxCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteKxDatabase ///

/// Deletes the specified database and all of its associated data. This action is irreversible. /// You must copy any data out of the database before deleting it if the data is to be /// retained. ///

/// Container for the necessary parameters to execute the DeleteKxDatabase service method. /// /// The response from the DeleteKxDatabase service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteKxDatabase Operation public virtual DeleteKxDatabaseResponse DeleteKxDatabase(DeleteKxDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKxDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKxDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteKxDatabase. /// /// Returns a DeleteKxDatabaseResult from Finspace. /// REST API Reference for DeleteKxDatabase Operation public virtual DeleteKxDatabaseResponse EndDeleteKxDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteKxEnvironment ///

/// Deletes the kdb environment. This action is irreversible. Deleting a kdb environment /// will remove all the associated data and any services running in it. ///

/// Container for the necessary parameters to execute the DeleteKxEnvironment service method. /// /// The response from the DeleteKxEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteKxEnvironment Operation public virtual DeleteKxEnvironmentResponse DeleteKxEnvironment(DeleteKxEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKxEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKxEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteKxEnvironment. /// /// Returns a DeleteKxEnvironmentResult from Finspace. /// REST API Reference for DeleteKxEnvironment Operation public virtual DeleteKxEnvironmentResponse EndDeleteKxEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteKxUser ///

/// Deletes a user in the specified kdb environment. ///

/// Container for the necessary parameters to execute the DeleteKxUser service method. /// /// The response from the DeleteKxUser service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteKxUser Operation public virtual DeleteKxUserResponse DeleteKxUser(DeleteKxUserRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteKxUserRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteKxUserResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginDeleteKxUser. /// /// Returns a DeleteKxUserResult from Finspace. /// REST API Reference for DeleteKxUser Operation public virtual DeleteKxUserResponse EndDeleteKxUser(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetEnvironment ///

/// Returns the FinSpace environment object. ///

/// Container for the necessary parameters to execute the GetEnvironment service method. /// /// The response from the GetEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetEnvironment Operation public virtual GetEnvironmentResponse GetEnvironment(GetEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetEnvironment. /// /// Returns a GetEnvironmentResult from Finspace. /// REST API Reference for GetEnvironment Operation public virtual GetEnvironmentResponse EndGetEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKxChangeset ///

/// Returns information about a kdb changeset. ///

/// Container for the necessary parameters to execute the GetKxChangeset service method. /// /// The response from the GetKxChangeset service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetKxChangeset Operation public virtual GetKxChangesetResponse GetKxChangeset(GetKxChangesetRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKxChangesetRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKxChangesetResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetKxChangeset. /// /// Returns a GetKxChangesetResult from Finspace. /// REST API Reference for GetKxChangeset Operation public virtual GetKxChangesetResponse EndGetKxChangeset(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKxCluster ///

/// Retrieves information about a kdb cluster. ///

/// Container for the necessary parameters to execute the GetKxCluster service method. /// /// The response from the GetKxCluster service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetKxCluster Operation public virtual GetKxClusterResponse GetKxCluster(GetKxClusterRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKxClusterRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKxClusterResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetKxCluster. /// /// Returns a GetKxClusterResult from Finspace. /// REST API Reference for GetKxCluster Operation public virtual GetKxClusterResponse EndGetKxCluster(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKxConnectionString ///

/// Retrieves a connection string for a user to connect to a kdb cluster. You must call /// this API using the same role that you have defined while creating a user. ///

/// Container for the necessary parameters to execute the GetKxConnectionString service method. /// /// The response from the GetKxConnectionString service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetKxConnectionString Operation public virtual GetKxConnectionStringResponse GetKxConnectionString(GetKxConnectionStringRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKxConnectionStringRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKxConnectionStringResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetKxConnectionString. /// /// Returns a GetKxConnectionStringResult from Finspace. /// REST API Reference for GetKxConnectionString Operation public virtual GetKxConnectionStringResponse EndGetKxConnectionString(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKxDatabase ///

/// Returns database information for the specified environment ID. ///

/// Container for the necessary parameters to execute the GetKxDatabase service method. /// /// The response from the GetKxDatabase service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetKxDatabase Operation public virtual GetKxDatabaseResponse GetKxDatabase(GetKxDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKxDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKxDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetKxDatabase. /// /// Returns a GetKxDatabaseResult from Finspace. /// REST API Reference for GetKxDatabase Operation public virtual GetKxDatabaseResponse EndGetKxDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKxEnvironment ///

/// Retrieves all the information for the specified kdb environment. ///

/// Container for the necessary parameters to execute the GetKxEnvironment service method. /// /// The response from the GetKxEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetKxEnvironment Operation public virtual GetKxEnvironmentResponse GetKxEnvironment(GetKxEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKxEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKxEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetKxEnvironment. /// /// Returns a GetKxEnvironmentResult from Finspace. /// REST API Reference for GetKxEnvironment Operation public virtual GetKxEnvironmentResponse EndGetKxEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetKxUser ///

/// Retrieves information about the specified kdb user. ///

/// Container for the necessary parameters to execute the GetKxUser service method. /// /// The response from the GetKxUser service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetKxUser Operation public virtual GetKxUserResponse GetKxUser(GetKxUserRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetKxUserRequestMarshaller.Instance; options.ResponseUnmarshaller = GetKxUserResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginGetKxUser. /// /// Returns a GetKxUserResult from Finspace. /// REST API Reference for GetKxUser Operation public virtual GetKxUserResponse EndGetKxUser(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListEnvironments ///

/// A list of all of your FinSpace environments. ///

/// Container for the necessary parameters to execute the ListEnvironments service method. /// /// The response from the ListEnvironments service method, as returned by Finspace. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListEnvironments Operation public virtual ListEnvironmentsResponse ListEnvironments(ListEnvironmentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListEnvironmentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEnvironmentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListEnvironments. /// /// Returns a ListEnvironmentsResult from Finspace. /// REST API Reference for ListEnvironments Operation public virtual ListEnvironmentsResponse EndListEnvironments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListKxChangesets ///

/// Returns a list of all the changesets for a database. ///

/// Container for the necessary parameters to execute the ListKxChangesets service method. /// /// The response from the ListKxChangesets service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListKxChangesets Operation public virtual ListKxChangesetsResponse ListKxChangesets(ListKxChangesetsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListKxChangesetsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKxChangesetsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListKxChangesets. /// /// Returns a ListKxChangesetsResult from Finspace. /// REST API Reference for ListKxChangesets Operation public virtual ListKxChangesetsResponse EndListKxChangesets(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListKxClusterNodes ///

/// Lists all the nodes in a kdb cluster. ///

/// Container for the necessary parameters to execute the ListKxClusterNodes service method. /// /// The response from the ListKxClusterNodes service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListKxClusterNodes Operation public virtual ListKxClusterNodesResponse ListKxClusterNodes(ListKxClusterNodesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListKxClusterNodesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKxClusterNodesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListKxClusterNodes. /// /// Returns a ListKxClusterNodesResult from Finspace. /// REST API Reference for ListKxClusterNodes Operation public virtual ListKxClusterNodesResponse EndListKxClusterNodes(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListKxClusters ///

/// Returns a list of clusters. ///

/// Container for the necessary parameters to execute the ListKxClusters service method. /// /// The response from the ListKxClusters service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListKxClusters Operation public virtual ListKxClustersResponse ListKxClusters(ListKxClustersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListKxClustersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKxClustersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListKxClusters. /// /// Returns a ListKxClustersResult from Finspace. /// REST API Reference for ListKxClusters Operation public virtual ListKxClustersResponse EndListKxClusters(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListKxDatabases ///

/// Returns a list of all the databases in the kdb environment. ///

/// Container for the necessary parameters to execute the ListKxDatabases service method. /// /// The response from the ListKxDatabases service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListKxDatabases Operation public virtual ListKxDatabasesResponse ListKxDatabases(ListKxDatabasesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListKxDatabasesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKxDatabasesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListKxDatabases. /// /// Returns a ListKxDatabasesResult from Finspace. /// REST API Reference for ListKxDatabases Operation public virtual ListKxDatabasesResponse EndListKxDatabases(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListKxEnvironments ///

/// Returns a list of kdb environments created in an account. ///

/// Container for the necessary parameters to execute the ListKxEnvironments service method. /// /// The response from the ListKxEnvironments service method, as returned by Finspace. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListKxEnvironments Operation public virtual ListKxEnvironmentsResponse ListKxEnvironments(ListKxEnvironmentsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListKxEnvironmentsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKxEnvironmentsResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListKxEnvironments. /// /// Returns a ListKxEnvironmentsResult from Finspace. /// REST API Reference for ListKxEnvironments Operation public virtual ListKxEnvironmentsResponse EndListKxEnvironments(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListKxUsers ///

/// Lists all the users in a kdb environment. ///

/// Container for the necessary parameters to execute the ListKxUsers service method. /// /// The response from the ListKxUsers service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListKxUsers Operation public virtual ListKxUsersResponse ListKxUsers(ListKxUsersRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListKxUsersRequestMarshaller.Instance; options.ResponseUnmarshaller = ListKxUsersResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginListKxUsers. /// /// Returns a ListKxUsersResult from Finspace. /// REST API Reference for ListKxUsers Operation public virtual ListKxUsersResponse EndListKxUsers(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource ///

/// A list of all tags for a resource. ///

/// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by Finspace. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The request is invalid. Something is wrong with the input to the request. /// /// /// One or more resources can't be found. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

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

/// Adds metadata tags to a FinSpace resource. ///

/// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by Finspace. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The request is invalid. Something is wrong with the input to the request. /// /// /// One or more resources can't be found. /// /// REST API Reference for TagResource Operation public virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginTagResource. /// /// Returns a TagResourceResult from Finspace. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource ///

/// Removes metadata tags from a FinSpace resource. ///

/// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by Finspace. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The request is invalid. Something is wrong with the input to the request. /// /// /// One or more resources can't be found. /// /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUntagResource. /// /// Returns a UntagResourceResult from Finspace. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateEnvironment ///

/// Update your FinSpace environment. ///

/// Container for the necessary parameters to execute the UpdateEnvironment service method. /// /// The response from the UpdateEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateEnvironment Operation public virtual UpdateEnvironmentResponse UpdateEnvironment(UpdateEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateEnvironment. /// /// Returns a UpdateEnvironmentResult from Finspace. /// REST API Reference for UpdateEnvironment Operation public virtual UpdateEnvironmentResponse EndUpdateEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateKxClusterDatabases ///

/// Updates the databases mounted on a kdb cluster, which includes the changesetId /// and all the dbPaths to be cached. This API does not allow you to change a database /// name or add a database if you created a cluster without one. /// /// /// /// Using this API you can point a cluster to a different changeset and modify a list /// of partitions being cached. /// ///

/// Container for the necessary parameters to execute the UpdateKxClusterDatabases service method. /// /// The response from the UpdateKxClusterDatabases service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateKxClusterDatabases Operation public virtual UpdateKxClusterDatabasesResponse UpdateKxClusterDatabases(UpdateKxClusterDatabasesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateKxClusterDatabasesRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateKxClusterDatabasesResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateKxClusterDatabases. /// /// Returns a UpdateKxClusterDatabasesResult from Finspace. /// REST API Reference for UpdateKxClusterDatabases Operation public virtual UpdateKxClusterDatabasesResponse EndUpdateKxClusterDatabases(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateKxDatabase ///

/// Updates information for the given kdb database. ///

/// Container for the necessary parameters to execute the UpdateKxDatabase service method. /// /// The response from the UpdateKxDatabase service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateKxDatabase Operation public virtual UpdateKxDatabaseResponse UpdateKxDatabase(UpdateKxDatabaseRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateKxDatabaseRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateKxDatabaseResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateKxDatabase. /// /// Returns a UpdateKxDatabaseResult from Finspace. /// REST API Reference for UpdateKxDatabase Operation public virtual UpdateKxDatabaseResponse EndUpdateKxDatabase(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateKxEnvironment ///

/// Updates information for the given kdb environment. ///

/// Container for the necessary parameters to execute the UpdateKxEnvironment service method. /// /// The response from the UpdateKxEnvironment service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateKxEnvironment Operation public virtual UpdateKxEnvironmentResponse UpdateKxEnvironment(UpdateKxEnvironmentRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateKxEnvironmentRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateKxEnvironmentResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateKxEnvironment. /// /// Returns a UpdateKxEnvironmentResult from Finspace. /// REST API Reference for UpdateKxEnvironment Operation public virtual UpdateKxEnvironmentResponse EndUpdateKxEnvironment(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateKxEnvironmentNetwork ///

/// Updates environment network to connect to your internal network by using a transit /// gateway. This API supports request to create a transit gateway attachment from FinSpace /// VPC to your transit gateway ID and create a custom Route-53 outbound resolvers. /// /// /// /// Once you send a request to update a network, you cannot change it again. Network update /// might require termination of any clusters that are running in the existing network. /// ///

/// Container for the necessary parameters to execute the UpdateKxEnvironmentNetwork service method. /// /// The response from the UpdateKxEnvironmentNetwork service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateKxEnvironmentNetwork Operation public virtual UpdateKxEnvironmentNetworkResponse UpdateKxEnvironmentNetwork(UpdateKxEnvironmentNetworkRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateKxEnvironmentNetworkRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateKxEnvironmentNetworkResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateKxEnvironmentNetwork. /// /// Returns a UpdateKxEnvironmentNetworkResult from Finspace. /// REST API Reference for UpdateKxEnvironmentNetwork Operation public virtual UpdateKxEnvironmentNetworkResponse EndUpdateKxEnvironmentNetwork(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateKxUser ///

/// Updates the user details. You can only update the IAM role associated with a user. ///

/// Container for the necessary parameters to execute the UpdateKxUser service method. /// /// The response from the UpdateKxUser service method, as returned by Finspace. /// /// You do not have sufficient access to perform this action. /// /// /// There was a conflict with this action, and it could not be completed. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// A service limit or quota is exceeded. /// /// /// One or more resources can't be found. /// /// /// The request was denied due to request throttling. /// /// /// The input fails to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateKxUser Operation public virtual UpdateKxUserResponse UpdateKxUser(UpdateKxUserRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateKxUserRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateKxUserResponseUnmarshaller.Instance; return Invoke(request, options); } ///

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

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

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

/// /// The IAsyncResult returned by the call to BeginUpdateKxUser. /// /// Returns a UpdateKxUserResult from Finspace. /// REST API Reference for UpdateKxUser Operation public virtual UpdateKxUserResponse EndUpdateKxUser(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }