/* * 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 redshift-serverless-2021-04-21.normal.json service model. */ using System; using System.Collections.Generic; using System.Net; using Amazon.RedshiftServerless.Model; using Amazon.RedshiftServerless.Model.Internal.MarshallTransformations; using Amazon.RedshiftServerless.Internal; using Amazon.Runtime; using Amazon.Runtime.Internal; using Amazon.Runtime.Internal.Auth; using Amazon.Runtime.Internal.Transform; namespace Amazon.RedshiftServerless { /// /// Implementation for accessing RedshiftServerless /// /// This is an interface reference for Amazon Redshift Serverless. It contains documentation /// for one of the programming or command line interfaces you can use to manage Amazon /// Redshift Serverless. /// /// /// /// Amazon Redshift Serverless automatically provisions data warehouse capacity and intelligently /// scales the underlying resources based on workload demands. Amazon Redshift Serverless /// adjusts capacity in seconds to deliver consistently high performance and simplified /// operations for even the most demanding and volatile workloads. Amazon Redshift Serverless /// lets you focus on using your data to acquire new insights for your business and customers. /// /// /// /// /// To learn more about Amazon Redshift Serverless, see What /// is Amazon Redshift Serverless. /// /// public partial class AmazonRedshiftServerlessClient : AmazonServiceClient, IAmazonRedshiftServerless { private static IServiceMetadata serviceMetadata = new AmazonRedshiftServerlessMetadata(); #if BCL45 || AWS_ASYNC_ENUMERABLES_API private IRedshiftServerlessPaginatorFactory _paginators; /// /// Paginators for the service /// public IRedshiftServerlessPaginatorFactory Paginators { get { if (this._paginators == null) { this._paginators = new RedshiftServerlessPaginatorFactory(this); } return this._paginators; } } #endif #region Constructors /// /// Constructs AmazonRedshiftServerlessClient 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 AmazonRedshiftServerlessClient() : base(FallbackCredentialsFactory.GetCredentials(), new AmazonRedshiftServerlessConfig()) { } /// /// Constructs AmazonRedshiftServerlessClient 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> /// /// /// /// The region to connect. public AmazonRedshiftServerlessClient(RegionEndpoint region) : base(FallbackCredentialsFactory.GetCredentials(), new AmazonRedshiftServerlessConfig{RegionEndpoint = region}) { } /// /// Constructs AmazonRedshiftServerlessClient 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> /// /// /// /// The AmazonRedshiftServerlessClient Configuration Object public AmazonRedshiftServerlessClient(AmazonRedshiftServerlessConfig config) : base(FallbackCredentialsFactory.GetCredentials(config), config){} /// /// Constructs AmazonRedshiftServerlessClient with AWS Credentials /// /// AWS Credentials public AmazonRedshiftServerlessClient(AWSCredentials credentials) : this(credentials, new AmazonRedshiftServerlessConfig()) { } /// /// Constructs AmazonRedshiftServerlessClient with AWS Credentials /// /// AWS Credentials /// The region to connect. public AmazonRedshiftServerlessClient(AWSCredentials credentials, RegionEndpoint region) : this(credentials, new AmazonRedshiftServerlessConfig{RegionEndpoint = region}) { } /// /// Constructs AmazonRedshiftServerlessClient with AWS Credentials and an /// AmazonRedshiftServerlessClient Configuration object. /// /// AWS Credentials /// The AmazonRedshiftServerlessClient Configuration Object public AmazonRedshiftServerlessClient(AWSCredentials credentials, AmazonRedshiftServerlessConfig clientConfig) : base(credentials, clientConfig) { } /// /// Constructs AmazonRedshiftServerlessClient with AWS Access Key ID and AWS Secret Key /// /// AWS Access Key ID /// AWS Secret Access Key public AmazonRedshiftServerlessClient(string awsAccessKeyId, string awsSecretAccessKey) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonRedshiftServerlessConfig()) { } /// /// Constructs AmazonRedshiftServerlessClient with AWS Access Key ID and AWS Secret Key /// /// AWS Access Key ID /// AWS Secret Access Key /// The region to connect. public AmazonRedshiftServerlessClient(string awsAccessKeyId, string awsSecretAccessKey, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, new AmazonRedshiftServerlessConfig() {RegionEndpoint=region}) { } /// /// Constructs AmazonRedshiftServerlessClient with AWS Access Key ID, AWS Secret Key and an /// AmazonRedshiftServerlessClient Configuration object. /// /// AWS Access Key ID /// AWS Secret Access Key /// The AmazonRedshiftServerlessClient Configuration Object public AmazonRedshiftServerlessClient(string awsAccessKeyId, string awsSecretAccessKey, AmazonRedshiftServerlessConfig clientConfig) : base(awsAccessKeyId, awsSecretAccessKey, clientConfig) { } /// /// Constructs AmazonRedshiftServerlessClient with AWS Access Key ID and AWS Secret Key /// /// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token public AmazonRedshiftServerlessClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonRedshiftServerlessConfig()) { } /// /// Constructs AmazonRedshiftServerlessClient 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 AmazonRedshiftServerlessClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, RegionEndpoint region) : this(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, new AmazonRedshiftServerlessConfig{RegionEndpoint = region}) { } /// /// Constructs AmazonRedshiftServerlessClient with AWS Access Key ID, AWS Secret Key and an /// AmazonRedshiftServerlessClient Configuration object. /// /// AWS Access Key ID /// AWS Secret Access Key /// AWS Session Token /// The AmazonRedshiftServerlessClient Configuration Object public AmazonRedshiftServerlessClient(string awsAccessKeyId, string awsSecretAccessKey, string awsSessionToken, AmazonRedshiftServerlessConfig 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 AmazonRedshiftServerlessEndpointResolver()); } /// /// 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 ConvertRecoveryPointToSnapshot /// /// Converts a recovery point to a snapshot. For more information about recovery points /// and snapshots, see Working /// with snapshots and recovery points. /// /// Container for the necessary parameters to execute the ConvertRecoveryPointToSnapshot service method. /// /// The response from the ConvertRecoveryPointToSnapshot service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The service limit was exceeded. /// /// /// The request exceeded the number of tags allowed for a resource. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ConvertRecoveryPointToSnapshot Operation public virtual ConvertRecoveryPointToSnapshotResponse ConvertRecoveryPointToSnapshot(ConvertRecoveryPointToSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ConvertRecoveryPointToSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ConvertRecoveryPointToSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ConvertRecoveryPointToSnapshot operation. /// /// /// Container for the necessary parameters to execute the ConvertRecoveryPointToSnapshot operation on AmazonRedshiftServerlessClient. /// 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 EndConvertRecoveryPointToSnapshot /// operation. /// REST API Reference for ConvertRecoveryPointToSnapshot Operation public virtual IAsyncResult BeginConvertRecoveryPointToSnapshot(ConvertRecoveryPointToSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ConvertRecoveryPointToSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ConvertRecoveryPointToSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ConvertRecoveryPointToSnapshot operation. /// /// /// The IAsyncResult returned by the call to BeginConvertRecoveryPointToSnapshot. /// /// Returns a ConvertRecoveryPointToSnapshotResult from RedshiftServerless. /// REST API Reference for ConvertRecoveryPointToSnapshot Operation public virtual ConvertRecoveryPointToSnapshotResponse EndConvertRecoveryPointToSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateEndpointAccess /// /// Creates an Amazon Redshift Serverless managed VPC endpoint. /// /// Container for the necessary parameters to execute the CreateEndpointAccess service method. /// /// The response from the CreateEndpointAccess service method, as returned by RedshiftServerless. /// /// You do not have sufficient access to perform this action. /// /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The service limit was exceeded. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateEndpointAccess Operation public virtual CreateEndpointAccessResponse CreateEndpointAccess(CreateEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the CreateEndpointAccess operation. /// /// /// Container for the necessary parameters to execute the CreateEndpointAccess operation on AmazonRedshiftServerlessClient. /// 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 EndCreateEndpointAccess /// operation. /// REST API Reference for CreateEndpointAccess Operation public virtual IAsyncResult BeginCreateEndpointAccess(CreateEndpointAccessRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEndpointAccessResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the CreateEndpointAccess operation. /// /// /// The IAsyncResult returned by the call to BeginCreateEndpointAccess. /// /// Returns a CreateEndpointAccessResult from RedshiftServerless. /// REST API Reference for CreateEndpointAccess Operation public virtual CreateEndpointAccessResponse EndCreateEndpointAccess(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateNamespace /// /// Creates a namespace in Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the CreateNamespace service method. /// /// The response from the CreateNamespace service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The request exceeded the number of tags allowed for a resource. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateNamespace Operation public virtual CreateNamespaceResponse CreateNamespace(CreateNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the CreateNamespace operation. /// /// /// Container for the necessary parameters to execute the CreateNamespace operation on AmazonRedshiftServerlessClient. /// 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 EndCreateNamespace /// operation. /// REST API Reference for CreateNamespace Operation public virtual IAsyncResult BeginCreateNamespace(CreateNamespaceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNamespaceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the CreateNamespace operation. /// /// /// The IAsyncResult returned by the call to BeginCreateNamespace. /// /// Returns a CreateNamespaceResult from RedshiftServerless. /// REST API Reference for CreateNamespace Operation public virtual CreateNamespaceResponse EndCreateNamespace(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateSnapshot /// /// Creates a snapshot of all databases in a namespace. For more information about snapshots, /// see /// Working with snapshots and recovery points. /// /// Container for the necessary parameters to execute the CreateSnapshot service method. /// /// The response from the CreateSnapshot service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The service limit was exceeded. /// /// /// The request exceeded the number of tags allowed for a resource. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the CreateSnapshot operation. /// /// /// Container for the necessary parameters to execute the CreateSnapshot operation on AmazonRedshiftServerlessClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndCreateSnapshot /// operation. /// REST API Reference for CreateSnapshot Operation public virtual IAsyncResult BeginCreateSnapshot(CreateSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the CreateSnapshot operation. /// /// /// The IAsyncResult returned by the call to BeginCreateSnapshot. /// /// Returns a CreateSnapshotResult from RedshiftServerless. /// REST API Reference for CreateSnapshot Operation public virtual CreateSnapshotResponse EndCreateSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateUsageLimit /// /// Creates a usage limit for a specified Amazon Redshift Serverless usage type. The usage /// limit is identified by the returned usage limit identifier. /// /// Container for the necessary parameters to execute the CreateUsageLimit service method. /// /// The response from the CreateUsageLimit service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The service limit was exceeded. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateUsageLimit Operation public virtual CreateUsageLimitResponse CreateUsageLimit(CreateUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the CreateUsageLimit operation. /// /// /// Container for the necessary parameters to execute the CreateUsageLimit operation on AmazonRedshiftServerlessClient. /// 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 EndCreateUsageLimit /// operation. /// REST API Reference for CreateUsageLimit Operation public virtual IAsyncResult BeginCreateUsageLimit(CreateUsageLimitRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUsageLimitResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the CreateUsageLimit operation. /// /// /// The IAsyncResult returned by the call to BeginCreateUsageLimit. /// /// Returns a CreateUsageLimitResult from RedshiftServerless. /// REST API Reference for CreateUsageLimit Operation public virtual CreateUsageLimitResponse EndCreateUsageLimit(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region CreateWorkgroup /// /// Creates an workgroup in Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the CreateWorkgroup service method. /// /// The response from the CreateWorkgroup service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// There is an insufficient capacity to perform the action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The request exceeded the number of tags allowed for a resource. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for CreateWorkgroup Operation public virtual CreateWorkgroupResponse CreateWorkgroup(CreateWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the CreateWorkgroup operation. /// /// /// Container for the necessary parameters to execute the CreateWorkgroup operation on AmazonRedshiftServerlessClient. /// 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 EndCreateWorkgroup /// operation. /// REST API Reference for CreateWorkgroup Operation public virtual IAsyncResult BeginCreateWorkgroup(CreateWorkgroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkgroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the CreateWorkgroup operation. /// /// /// The IAsyncResult returned by the call to BeginCreateWorkgroup. /// /// Returns a CreateWorkgroupResult from RedshiftServerless. /// REST API Reference for CreateWorkgroup Operation public virtual CreateWorkgroupResponse EndCreateWorkgroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteEndpointAccess /// /// Deletes an Amazon Redshift Serverless managed VPC endpoint. /// /// Container for the necessary parameters to execute the DeleteEndpointAccess service method. /// /// The response from the DeleteEndpointAccess service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteEndpointAccess Operation public virtual DeleteEndpointAccessResponse DeleteEndpointAccess(DeleteEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the DeleteEndpointAccess operation. /// /// /// Container for the necessary parameters to execute the DeleteEndpointAccess operation on AmazonRedshiftServerlessClient. /// 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 EndDeleteEndpointAccess /// operation. /// REST API Reference for DeleteEndpointAccess Operation public virtual IAsyncResult BeginDeleteEndpointAccess(DeleteEndpointAccessRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEndpointAccessResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the DeleteEndpointAccess operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteEndpointAccess. /// /// Returns a DeleteEndpointAccessResult from RedshiftServerless. /// REST API Reference for DeleteEndpointAccess Operation public virtual DeleteEndpointAccessResponse EndDeleteEndpointAccess(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteNamespace /// /// Deletes a namespace from Amazon Redshift Serverless. Before you delete the namespace, /// you can create a final snapshot that has all of the data within the namespace. /// /// Container for the necessary parameters to execute the DeleteNamespace service method. /// /// The response from the DeleteNamespace service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteNamespace Operation public virtual DeleteNamespaceResponse DeleteNamespace(DeleteNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the DeleteNamespace operation. /// /// /// Container for the necessary parameters to execute the DeleteNamespace operation on AmazonRedshiftServerlessClient. /// 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 EndDeleteNamespace /// operation. /// REST API Reference for DeleteNamespace Operation public virtual IAsyncResult BeginDeleteNamespace(DeleteNamespaceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteNamespaceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the DeleteNamespace operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteNamespace. /// /// Returns a DeleteNamespaceResult from RedshiftServerless. /// REST API Reference for DeleteNamespace Operation public virtual DeleteNamespaceResponse EndDeleteNamespace(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteResourcePolicy /// /// Deletes the specified resource policy. /// /// Container for the necessary parameters to execute the DeleteResourcePolicy service method. /// /// The response from the DeleteResourcePolicy service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteResourcePolicy Operation public virtual DeleteResourcePolicyResponse DeleteResourcePolicy(DeleteResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the DeleteResourcePolicy operation. /// /// /// Container for the necessary parameters to execute the DeleteResourcePolicy operation on AmazonRedshiftServerlessClient. /// 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 EndDeleteResourcePolicy /// operation. /// REST API Reference for DeleteResourcePolicy Operation public virtual IAsyncResult BeginDeleteResourcePolicy(DeleteResourcePolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the DeleteResourcePolicy operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteResourcePolicy. /// /// Returns a DeleteResourcePolicyResult from RedshiftServerless. /// REST API Reference for DeleteResourcePolicy Operation public virtual DeleteResourcePolicyResponse EndDeleteResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteSnapshot /// /// Deletes a snapshot from Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the DeleteSnapshot service method. /// /// The response from the DeleteSnapshot service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteSnapshot Operation public virtual DeleteSnapshotResponse DeleteSnapshot(DeleteSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the DeleteSnapshot operation. /// /// /// Container for the necessary parameters to execute the DeleteSnapshot operation on AmazonRedshiftServerlessClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteSnapshot /// operation. /// REST API Reference for DeleteSnapshot Operation public virtual IAsyncResult BeginDeleteSnapshot(DeleteSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the DeleteSnapshot operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteSnapshot. /// /// Returns a DeleteSnapshotResult from RedshiftServerless. /// REST API Reference for DeleteSnapshot Operation public virtual DeleteSnapshotResponse EndDeleteSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteUsageLimit /// /// Deletes a usage limit from Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the DeleteUsageLimit service method. /// /// The response from the DeleteUsageLimit service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteUsageLimit Operation public virtual DeleteUsageLimitResponse DeleteUsageLimit(DeleteUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the DeleteUsageLimit operation. /// /// /// Container for the necessary parameters to execute the DeleteUsageLimit operation on AmazonRedshiftServerlessClient. /// 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 EndDeleteUsageLimit /// operation. /// REST API Reference for DeleteUsageLimit Operation public virtual IAsyncResult BeginDeleteUsageLimit(DeleteUsageLimitRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUsageLimitResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the DeleteUsageLimit operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteUsageLimit. /// /// Returns a DeleteUsageLimitResult from RedshiftServerless. /// REST API Reference for DeleteUsageLimit Operation public virtual DeleteUsageLimitResponse EndDeleteUsageLimit(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region DeleteWorkgroup /// /// Deletes a workgroup. /// /// Container for the necessary parameters to execute the DeleteWorkgroup service method. /// /// The response from the DeleteWorkgroup service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for DeleteWorkgroup Operation public virtual DeleteWorkgroupResponse DeleteWorkgroup(DeleteWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the DeleteWorkgroup operation. /// /// /// Container for the necessary parameters to execute the DeleteWorkgroup operation on AmazonRedshiftServerlessClient. /// 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 EndDeleteWorkgroup /// operation. /// REST API Reference for DeleteWorkgroup Operation public virtual IAsyncResult BeginDeleteWorkgroup(DeleteWorkgroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkgroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the DeleteWorkgroup operation. /// /// /// The IAsyncResult returned by the call to BeginDeleteWorkgroup. /// /// Returns a DeleteWorkgroupResult from RedshiftServerless. /// REST API Reference for DeleteWorkgroup Operation public virtual DeleteWorkgroupResponse EndDeleteWorkgroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetCredentials /// /// Returns a database user name and temporary password with temporary authorization to /// log in to Amazon Redshift Serverless. /// /// /// /// By default, the temporary credentials expire in 900 seconds. You can optionally specify /// a duration between 900 seconds (15 minutes) and 3600 seconds (60 minutes). /// /// 
 <p>The Identity and Access Management (IAM) user or role that runs
        /// GetCredentials must have an IAM policy attached that allows access to all necessary
        /// actions and resources.</p> <p>If the <code>DbName</code> parameter
        /// is specified, the IAM policy must allow access to the resource dbname for the specified
        /// database name.</p>
/// /// Container for the necessary parameters to execute the GetCredentials service method. /// /// The response from the GetCredentials service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetCredentials Operation public virtual GetCredentialsResponse GetCredentials(GetCredentialsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCredentialsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetCredentials operation. /// /// /// Container for the necessary parameters to execute the GetCredentials operation on AmazonRedshiftServerlessClient. /// 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 EndGetCredentials /// operation. /// REST API Reference for GetCredentials Operation public virtual IAsyncResult BeginGetCredentials(GetCredentialsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCredentialsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetCredentials operation. /// /// /// The IAsyncResult returned by the call to BeginGetCredentials. /// /// Returns a GetCredentialsResult from RedshiftServerless. /// REST API Reference for GetCredentials Operation public virtual GetCredentialsResponse EndGetCredentials(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetEndpointAccess /// /// Returns information, such as the name, about a VPC endpoint. /// /// Container for the necessary parameters to execute the GetEndpointAccess service method. /// /// The response from the GetEndpointAccess service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetEndpointAccess Operation public virtual GetEndpointAccessResponse GetEndpointAccess(GetEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetEndpointAccess operation. /// /// /// Container for the necessary parameters to execute the GetEndpointAccess operation on AmazonRedshiftServerlessClient. /// 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 EndGetEndpointAccess /// operation. /// REST API Reference for GetEndpointAccess Operation public virtual IAsyncResult BeginGetEndpointAccess(GetEndpointAccessRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEndpointAccessResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetEndpointAccess operation. /// /// /// The IAsyncResult returned by the call to BeginGetEndpointAccess. /// /// Returns a GetEndpointAccessResult from RedshiftServerless. /// REST API Reference for GetEndpointAccess Operation public virtual GetEndpointAccessResponse EndGetEndpointAccess(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetNamespace /// /// Returns information about a namespace in Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the GetNamespace service method. /// /// The response from the GetNamespace service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetNamespace Operation public virtual GetNamespaceResponse GetNamespace(GetNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetNamespace operation. /// /// /// Container for the necessary parameters to execute the GetNamespace operation on AmazonRedshiftServerlessClient. /// 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 EndGetNamespace /// operation. /// REST API Reference for GetNamespace Operation public virtual IAsyncResult BeginGetNamespace(GetNamespaceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNamespaceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetNamespace operation. /// /// /// The IAsyncResult returned by the call to BeginGetNamespace. /// /// Returns a GetNamespaceResult from RedshiftServerless. /// REST API Reference for GetNamespace Operation public virtual GetNamespaceResponse EndGetNamespace(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetRecoveryPoint /// /// Returns information about a recovery point. /// /// Container for the necessary parameters to execute the GetRecoveryPoint service method. /// /// The response from the GetRecoveryPoint service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetRecoveryPoint Operation public virtual GetRecoveryPointResponse GetRecoveryPoint(GetRecoveryPointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRecoveryPointResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetRecoveryPoint operation. /// /// /// Container for the necessary parameters to execute the GetRecoveryPoint operation on AmazonRedshiftServerlessClient. /// 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 EndGetRecoveryPoint /// operation. /// REST API Reference for GetRecoveryPoint Operation public virtual IAsyncResult BeginGetRecoveryPoint(GetRecoveryPointRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRecoveryPointResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetRecoveryPoint operation. /// /// /// The IAsyncResult returned by the call to BeginGetRecoveryPoint. /// /// Returns a GetRecoveryPointResult from RedshiftServerless. /// REST API Reference for GetRecoveryPoint Operation public virtual GetRecoveryPointResponse EndGetRecoveryPoint(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetResourcePolicy /// /// Returns a resource policy. /// /// Container for the necessary parameters to execute the GetResourcePolicy service method. /// /// The response from the GetResourcePolicy service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetResourcePolicy Operation public virtual GetResourcePolicyResponse GetResourcePolicy(GetResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetResourcePolicy operation. /// /// /// Container for the necessary parameters to execute the GetResourcePolicy operation on AmazonRedshiftServerlessClient. /// 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 EndGetResourcePolicy /// operation. /// REST API Reference for GetResourcePolicy Operation public virtual IAsyncResult BeginGetResourcePolicy(GetResourcePolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetResourcePolicy operation. /// /// /// The IAsyncResult returned by the call to BeginGetResourcePolicy. /// /// Returns a GetResourcePolicyResult from RedshiftServerless. /// REST API Reference for GetResourcePolicy Operation public virtual GetResourcePolicyResponse EndGetResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetSnapshot /// /// Returns information about a specific snapshot. /// /// Container for the necessary parameters to execute the GetSnapshot service method. /// /// The response from the GetSnapshot service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetSnapshot Operation public virtual GetSnapshotResponse GetSnapshot(GetSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetSnapshot operation. /// /// /// Container for the necessary parameters to execute the GetSnapshot operation on AmazonRedshiftServerlessClient. /// 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 EndGetSnapshot /// operation. /// REST API Reference for GetSnapshot Operation public virtual IAsyncResult BeginGetSnapshot(GetSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetSnapshot operation. /// /// /// The IAsyncResult returned by the call to BeginGetSnapshot. /// /// Returns a GetSnapshotResult from RedshiftServerless. /// REST API Reference for GetSnapshot Operation public virtual GetSnapshotResponse EndGetSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetTableRestoreStatus /// /// Returns information about a TableRestoreStatus object. /// /// Container for the necessary parameters to execute the GetTableRestoreStatus service method. /// /// The response from the GetTableRestoreStatus service method, as returned by RedshiftServerless. /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetTableRestoreStatus Operation public virtual GetTableRestoreStatusResponse GetTableRestoreStatus(GetTableRestoreStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTableRestoreStatusResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetTableRestoreStatus operation. /// /// /// Container for the necessary parameters to execute the GetTableRestoreStatus operation on AmazonRedshiftServerlessClient. /// 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 EndGetTableRestoreStatus /// operation. /// REST API Reference for GetTableRestoreStatus Operation public virtual IAsyncResult BeginGetTableRestoreStatus(GetTableRestoreStatusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTableRestoreStatusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetTableRestoreStatus operation. /// /// /// The IAsyncResult returned by the call to BeginGetTableRestoreStatus. /// /// Returns a GetTableRestoreStatusResult from RedshiftServerless. /// REST API Reference for GetTableRestoreStatus Operation public virtual GetTableRestoreStatusResponse EndGetTableRestoreStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetUsageLimit /// /// Returns information about a usage limit. /// /// Container for the necessary parameters to execute the GetUsageLimit service method. /// /// The response from the GetUsageLimit service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetUsageLimit Operation public virtual GetUsageLimitResponse GetUsageLimit(GetUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = GetUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetUsageLimit operation. /// /// /// Container for the necessary parameters to execute the GetUsageLimit operation on AmazonRedshiftServerlessClient. /// 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 EndGetUsageLimit /// operation. /// REST API Reference for GetUsageLimit Operation public virtual IAsyncResult BeginGetUsageLimit(GetUsageLimitRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = GetUsageLimitResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetUsageLimit operation. /// /// /// The IAsyncResult returned by the call to BeginGetUsageLimit. /// /// Returns a GetUsageLimitResult from RedshiftServerless. /// REST API Reference for GetUsageLimit Operation public virtual GetUsageLimitResponse EndGetUsageLimit(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region GetWorkgroup /// /// Returns information about a specific workgroup. /// /// Container for the necessary parameters to execute the GetWorkgroup service method. /// /// The response from the GetWorkgroup service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for GetWorkgroup Operation public virtual GetWorkgroupResponse GetWorkgroup(GetWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the GetWorkgroup operation. /// /// /// Container for the necessary parameters to execute the GetWorkgroup operation on AmazonRedshiftServerlessClient. /// 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 EndGetWorkgroup /// operation. /// REST API Reference for GetWorkgroup Operation public virtual IAsyncResult BeginGetWorkgroup(GetWorkgroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkgroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the GetWorkgroup operation. /// /// /// The IAsyncResult returned by the call to BeginGetWorkgroup. /// /// Returns a GetWorkgroupResult from RedshiftServerless. /// REST API Reference for GetWorkgroup Operation public virtual GetWorkgroupResponse EndGetWorkgroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListEndpointAccess /// /// Returns an array of EndpointAccess objects and relevant information. /// /// Container for the necessary parameters to execute the ListEndpointAccess service method. /// /// The response from the ListEndpointAccess service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListEndpointAccess Operation public virtual ListEndpointAccessResponse ListEndpointAccess(ListEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListEndpointAccess operation. /// /// /// Container for the necessary parameters to execute the ListEndpointAccess operation on AmazonRedshiftServerlessClient. /// 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 EndListEndpointAccess /// operation. /// REST API Reference for ListEndpointAccess Operation public virtual IAsyncResult BeginListEndpointAccess(ListEndpointAccessRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEndpointAccessResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ListEndpointAccess operation. /// /// /// The IAsyncResult returned by the call to BeginListEndpointAccess. /// /// Returns a ListEndpointAccessResult from RedshiftServerless. /// REST API Reference for ListEndpointAccess Operation public virtual ListEndpointAccessResponse EndListEndpointAccess(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListNamespaces /// /// Returns information about a list of specified namespaces. /// /// Container for the necessary parameters to execute the ListNamespaces service method. /// /// The response from the ListNamespaces service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListNamespaces Operation public virtual ListNamespacesResponse ListNamespaces(ListNamespacesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListNamespacesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNamespacesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListNamespaces operation. /// /// /// Container for the necessary parameters to execute the ListNamespaces operation on AmazonRedshiftServerlessClient. /// 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 EndListNamespaces /// operation. /// REST API Reference for ListNamespaces Operation public virtual IAsyncResult BeginListNamespaces(ListNamespacesRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListNamespacesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNamespacesResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ListNamespaces operation. /// /// /// The IAsyncResult returned by the call to BeginListNamespaces. /// /// Returns a ListNamespacesResult from RedshiftServerless. /// REST API Reference for ListNamespaces Operation public virtual ListNamespacesResponse EndListNamespaces(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListRecoveryPoints /// /// Returns an array of recovery points. /// /// Container for the necessary parameters to execute the ListRecoveryPoints service method. /// /// The response from the ListRecoveryPoints service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListRecoveryPoints Operation public virtual ListRecoveryPointsResponse ListRecoveryPoints(ListRecoveryPointsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListRecoveryPointsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRecoveryPointsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListRecoveryPoints operation. /// /// /// Container for the necessary parameters to execute the ListRecoveryPoints operation on AmazonRedshiftServerlessClient. /// 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 EndListRecoveryPoints /// operation. /// REST API Reference for ListRecoveryPoints Operation public virtual IAsyncResult BeginListRecoveryPoints(ListRecoveryPointsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListRecoveryPointsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRecoveryPointsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ListRecoveryPoints operation. /// /// /// The IAsyncResult returned by the call to BeginListRecoveryPoints. /// /// Returns a ListRecoveryPointsResult from RedshiftServerless. /// REST API Reference for ListRecoveryPoints Operation public virtual ListRecoveryPointsResponse EndListRecoveryPoints(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListSnapshots /// /// Returns a list of snapshots. /// /// Container for the necessary parameters to execute the ListSnapshots service method. /// /// The response from the ListSnapshots service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListSnapshots Operation public virtual ListSnapshotsResponse ListSnapshots(ListSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListSnapshots operation. /// /// /// Container for the necessary parameters to execute the ListSnapshots operation on AmazonRedshiftServerlessClient. /// 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 EndListSnapshots /// operation. /// REST API Reference for ListSnapshots Operation public virtual IAsyncResult BeginListSnapshots(ListSnapshotsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSnapshotsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ListSnapshots operation. /// /// /// The IAsyncResult returned by the call to BeginListSnapshots. /// /// Returns a ListSnapshotsResult from RedshiftServerless. /// REST API Reference for ListSnapshots Operation public virtual ListSnapshotsResponse EndListSnapshots(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTableRestoreStatus /// /// Returns information about an array of TableRestoreStatus objects. /// /// Container for the necessary parameters to execute the ListTableRestoreStatus service method. /// /// The response from the ListTableRestoreStatus service method, as returned by RedshiftServerless. /// /// The provided pagination token is invalid. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListTableRestoreStatus Operation public virtual ListTableRestoreStatusResponse ListTableRestoreStatus(ListTableRestoreStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTableRestoreStatusResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListTableRestoreStatus operation. /// /// /// Container for the necessary parameters to execute the ListTableRestoreStatus operation on AmazonRedshiftServerlessClient. /// 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 EndListTableRestoreStatus /// operation. /// REST API Reference for ListTableRestoreStatus Operation public virtual IAsyncResult BeginListTableRestoreStatus(ListTableRestoreStatusRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTableRestoreStatusResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ListTableRestoreStatus operation. /// /// /// The IAsyncResult returned by the call to BeginListTableRestoreStatus. /// /// Returns a ListTableRestoreStatusResult from RedshiftServerless. /// REST API Reference for ListTableRestoreStatus Operation public virtual ListTableRestoreStatusResponse EndListTableRestoreStatus(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListTagsForResource /// /// Lists the tags assigned to a resource. /// /// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// The response from the ListTagsForResource service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListTagsForResource operation. /// /// /// Container for the necessary parameters to execute the ListTagsForResource operation on AmazonRedshiftServerlessClient. /// 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 RedshiftServerless. /// REST API Reference for ListTagsForResource Operation public virtual ListTagsForResourceResponse EndListTagsForResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListUsageLimits /// /// Lists all usage limits within Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the ListUsageLimits service method. /// /// The response from the ListUsageLimits service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The provided pagination token is invalid. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListUsageLimits Operation public virtual ListUsageLimitsResponse ListUsageLimits(ListUsageLimitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListUsageLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListUsageLimitsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListUsageLimits operation. /// /// /// Container for the necessary parameters to execute the ListUsageLimits operation on AmazonRedshiftServerlessClient. /// 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 EndListUsageLimits /// operation. /// REST API Reference for ListUsageLimits Operation public virtual IAsyncResult BeginListUsageLimits(ListUsageLimitsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListUsageLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListUsageLimitsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ListUsageLimits operation. /// /// /// The IAsyncResult returned by the call to BeginListUsageLimits. /// /// Returns a ListUsageLimitsResult from RedshiftServerless. /// REST API Reference for ListUsageLimits Operation public virtual ListUsageLimitsResponse EndListUsageLimits(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region ListWorkgroups /// /// Returns information about a list of specified workgroups. /// /// Container for the necessary parameters to execute the ListWorkgroups service method. /// /// The response from the ListWorkgroups service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for ListWorkgroups Operation public virtual ListWorkgroupsResponse ListWorkgroups(ListWorkgroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkgroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkgroupsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the ListWorkgroups operation. /// /// /// Container for the necessary parameters to execute the ListWorkgroups operation on AmazonRedshiftServerlessClient. /// 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 EndListWorkgroups /// operation. /// REST API Reference for ListWorkgroups Operation public virtual IAsyncResult BeginListWorkgroups(ListWorkgroupsRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkgroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkgroupsResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the ListWorkgroups operation. /// /// /// The IAsyncResult returned by the call to BeginListWorkgroups. /// /// Returns a ListWorkgroupsResult from RedshiftServerless. /// REST API Reference for ListWorkgroups Operation public virtual ListWorkgroupsResponse EndListWorkgroups(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region PutResourcePolicy /// /// Creates or updates a resource policy. Currently, you can use policies to share snapshots /// across Amazon Web Services accounts. /// /// Container for the necessary parameters to execute the PutResourcePolicy service method. /// /// The response from the PutResourcePolicy service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The service limit was exceeded. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for PutResourcePolicy Operation public virtual PutResourcePolicyResponse PutResourcePolicy(PutResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the PutResourcePolicy operation. /// /// /// Container for the necessary parameters to execute the PutResourcePolicy operation on AmazonRedshiftServerlessClient. /// 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 EndPutResourcePolicy /// operation. /// REST API Reference for PutResourcePolicy Operation public virtual IAsyncResult BeginPutResourcePolicy(PutResourcePolicyRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the PutResourcePolicy operation. /// /// /// The IAsyncResult returned by the call to BeginPutResourcePolicy. /// /// Returns a PutResourcePolicyResult from RedshiftServerless. /// REST API Reference for PutResourcePolicy Operation public virtual PutResourcePolicyResponse EndPutResourcePolicy(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RestoreFromRecoveryPoint /// /// Restore the data from a recovery point. /// /// Container for the necessary parameters to execute the RestoreFromRecoveryPoint service method. /// /// The response from the RestoreFromRecoveryPoint service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for RestoreFromRecoveryPoint Operation public virtual RestoreFromRecoveryPointResponse RestoreFromRecoveryPoint(RestoreFromRecoveryPointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromRecoveryPointResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the RestoreFromRecoveryPoint operation. /// /// /// Container for the necessary parameters to execute the RestoreFromRecoveryPoint operation on AmazonRedshiftServerlessClient. /// 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 EndRestoreFromRecoveryPoint /// operation. /// REST API Reference for RestoreFromRecoveryPoint Operation public virtual IAsyncResult BeginRestoreFromRecoveryPoint(RestoreFromRecoveryPointRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromRecoveryPointResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the RestoreFromRecoveryPoint operation. /// /// /// The IAsyncResult returned by the call to BeginRestoreFromRecoveryPoint. /// /// Returns a RestoreFromRecoveryPointResult from RedshiftServerless. /// REST API Reference for RestoreFromRecoveryPoint Operation public virtual RestoreFromRecoveryPointResponse EndRestoreFromRecoveryPoint(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RestoreFromSnapshot /// /// Restores a namespace from a snapshot. /// /// Container for the necessary parameters to execute the RestoreFromSnapshot service method. /// /// The response from the RestoreFromSnapshot service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The service limit was exceeded. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for RestoreFromSnapshot Operation public virtual RestoreFromSnapshotResponse RestoreFromSnapshot(RestoreFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the RestoreFromSnapshot operation. /// /// /// Container for the necessary parameters to execute the RestoreFromSnapshot operation on AmazonRedshiftServerlessClient. /// An AsyncCallback delegate that is invoked when the operation completes. /// A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property. /// /// An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndRestoreFromSnapshot /// operation. /// REST API Reference for RestoreFromSnapshot Operation public virtual IAsyncResult BeginRestoreFromSnapshot(RestoreFromSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the RestoreFromSnapshot operation. /// /// /// The IAsyncResult returned by the call to BeginRestoreFromSnapshot. /// /// Returns a RestoreFromSnapshotResult from RedshiftServerless. /// REST API Reference for RestoreFromSnapshot Operation public virtual RestoreFromSnapshotResponse EndRestoreFromSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region RestoreTableFromSnapshot /// /// Restores a table from a snapshot to your Amazon Redshift Serverless instance. You /// can't use this operation to restore tables with interleaved /// sort keys. /// /// Container for the necessary parameters to execute the RestoreTableFromSnapshot service method. /// /// The response from the RestoreTableFromSnapshot service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for RestoreTableFromSnapshot Operation public virtual RestoreTableFromSnapshotResponse RestoreTableFromSnapshot(RestoreTableFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreTableFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreTableFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the RestoreTableFromSnapshot operation. /// /// /// Container for the necessary parameters to execute the RestoreTableFromSnapshot operation on AmazonRedshiftServerlessClient. /// 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 EndRestoreTableFromSnapshot /// operation. /// REST API Reference for RestoreTableFromSnapshot Operation public virtual IAsyncResult BeginRestoreTableFromSnapshot(RestoreTableFromSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreTableFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreTableFromSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the RestoreTableFromSnapshot operation. /// /// /// The IAsyncResult returned by the call to BeginRestoreTableFromSnapshot. /// /// Returns a RestoreTableFromSnapshotResult from RedshiftServerless. /// REST API Reference for RestoreTableFromSnapshot Operation public virtual RestoreTableFromSnapshotResponse EndRestoreTableFromSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region TagResource /// /// Assigns one or more tags to a resource. /// /// Container for the necessary parameters to execute the TagResource service method. /// /// The response from the TagResource service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The request exceeded the number of tags allowed for a resource. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// 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 AmazonRedshiftServerlessClient. /// 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 RedshiftServerless. /// REST API Reference for TagResource Operation public virtual TagResourceResponse EndTagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UntagResource /// /// Removes a tag or set of tags from a resource. /// /// Container for the necessary parameters to execute the UntagResource service method. /// /// The response from the UntagResource service method, as returned by RedshiftServerless. /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The request was denied due to request throttling. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// 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 AmazonRedshiftServerlessClient. /// 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 RedshiftServerless. /// REST API Reference for UntagResource Operation public virtual UntagResourceResponse EndUntagResource(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateEndpointAccess /// /// Updates an Amazon Redshift Serverless managed endpoint. /// /// Container for the necessary parameters to execute the UpdateEndpointAccess service method. /// /// The response from the UpdateEndpointAccess service method, as returned by RedshiftServerless. /// /// You do not have sufficient access to perform this action. /// /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateEndpointAccess Operation public virtual UpdateEndpointAccessResponse UpdateEndpointAccess(UpdateEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the UpdateEndpointAccess operation. /// /// /// Container for the necessary parameters to execute the UpdateEndpointAccess operation on AmazonRedshiftServerlessClient. /// 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 EndUpdateEndpointAccess /// operation. /// REST API Reference for UpdateEndpointAccess Operation public virtual IAsyncResult BeginUpdateEndpointAccess(UpdateEndpointAccessRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateEndpointAccessResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the UpdateEndpointAccess operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateEndpointAccess. /// /// Returns a UpdateEndpointAccessResult from RedshiftServerless. /// REST API Reference for UpdateEndpointAccess Operation public virtual UpdateEndpointAccessResponse EndUpdateEndpointAccess(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateNamespace /// /// Updates a namespace with the specified settings. Unless required, you can't update /// multiple parameters in one request. For example, you must specify both adminUsername /// and adminUserPassword to update either field, but you can't update both /// kmsKeyId and logExports in a single request. /// /// Container for the necessary parameters to execute the UpdateNamespace service method. /// /// The response from the UpdateNamespace service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateNamespace Operation public virtual UpdateNamespaceResponse UpdateNamespace(UpdateNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the UpdateNamespace operation. /// /// /// Container for the necessary parameters to execute the UpdateNamespace operation on AmazonRedshiftServerlessClient. /// 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 EndUpdateNamespace /// operation. /// REST API Reference for UpdateNamespace Operation public virtual IAsyncResult BeginUpdateNamespace(UpdateNamespaceRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNamespaceResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the UpdateNamespace operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateNamespace. /// /// Returns a UpdateNamespaceResult from RedshiftServerless. /// REST API Reference for UpdateNamespace Operation public virtual UpdateNamespaceResponse EndUpdateNamespace(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateSnapshot /// /// Updates a snapshot. /// /// Container for the necessary parameters to execute the UpdateSnapshot service method. /// /// The response from the UpdateSnapshot service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateSnapshot Operation public virtual UpdateSnapshotResponse UpdateSnapshot(UpdateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the UpdateSnapshot operation. /// /// /// Container for the necessary parameters to execute the UpdateSnapshot operation on AmazonRedshiftServerlessClient. /// 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 EndUpdateSnapshot /// operation. /// REST API Reference for UpdateSnapshot Operation public virtual IAsyncResult BeginUpdateSnapshot(UpdateSnapshotRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSnapshotResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the UpdateSnapshot operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateSnapshot. /// /// Returns a UpdateSnapshotResult from RedshiftServerless. /// REST API Reference for UpdateSnapshot Operation public virtual UpdateSnapshotResponse EndUpdateSnapshot(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateUsageLimit /// /// Update a usage limit in Amazon Redshift Serverless. You can't update the usage type /// or period of a usage limit. /// /// Container for the necessary parameters to execute the UpdateUsageLimit service method. /// /// The response from the UpdateUsageLimit service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateUsageLimit Operation public virtual UpdateUsageLimitResponse UpdateUsageLimit(UpdateUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the UpdateUsageLimit operation. /// /// /// Container for the necessary parameters to execute the UpdateUsageLimit operation on AmazonRedshiftServerlessClient. /// 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 EndUpdateUsageLimit /// operation. /// REST API Reference for UpdateUsageLimit Operation public virtual IAsyncResult BeginUpdateUsageLimit(UpdateUsageLimitRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUsageLimitResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the UpdateUsageLimit operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateUsageLimit. /// /// Returns a UpdateUsageLimitResult from RedshiftServerless. /// REST API Reference for UpdateUsageLimit Operation public virtual UpdateUsageLimitResponse EndUpdateUsageLimit(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion #region UpdateWorkgroup /// /// Updates a workgroup with the specified configuration settings. You can't update multiple /// parameters in one request. For example, you can update baseCapacity or /// port in a single request, but you can't update both in the same request. /// /// Container for the necessary parameters to execute the UpdateWorkgroup service method. /// /// The response from the UpdateWorkgroup service method, as returned by RedshiftServerless. /// /// The submitted action has conflicts. /// /// /// There is an insufficient capacity to perform the action. /// /// /// The request processing has failed because of an unknown error, exception or failure. /// /// /// The resource could not be found. /// /// /// The input failed to satisfy the constraints specified by an AWS service. /// /// REST API Reference for UpdateWorkgroup Operation public virtual UpdateWorkgroupResponse UpdateWorkgroup(UpdateWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Initiates the asynchronous execution of the UpdateWorkgroup operation. /// /// /// Container for the necessary parameters to execute the UpdateWorkgroup operation on AmazonRedshiftServerlessClient. /// 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 EndUpdateWorkgroup /// operation. /// REST API Reference for UpdateWorkgroup Operation public virtual IAsyncResult BeginUpdateWorkgroup(UpdateWorkgroupRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkgroupResponseUnmarshaller.Instance; return BeginInvoke(request, options, callback, state); } /// /// Finishes the asynchronous execution of the UpdateWorkgroup operation. /// /// /// The IAsyncResult returned by the call to BeginUpdateWorkgroup. /// /// Returns a UpdateWorkgroupResult from RedshiftServerless. /// REST API Reference for UpdateWorkgroup Operation public virtual UpdateWorkgroupResponse EndUpdateWorkgroup(IAsyncResult asyncResult) { return EndInvoke(asyncResult); } #endregion } }