/* * 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.Runtime.ExceptionServices; using System.Threading; using System.Threading.Tasks; 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(); #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 #if 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 Overrides /// /// Creates the signer for the service. /// protected override AbstractAWSSigner CreateSigner() { return new AWS4Signer(); } /// /// Customizes the runtime pipeline. /// /// Runtime pipeline for the current client. protected override void CustomizeRuntimePipeline(RuntimePipeline pipeline) { pipeline.RemoveHandler(); pipeline.AddHandlerAfter(new 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 internal virtual ConvertRecoveryPointToSnapshotResponse ConvertRecoveryPointToSnapshot(ConvertRecoveryPointToSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ConvertRecoveryPointToSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ConvertRecoveryPointToSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ConvertRecoveryPointToSnapshotAsync(ConvertRecoveryPointToSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ConvertRecoveryPointToSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = ConvertRecoveryPointToSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateEndpointAccess internal virtual CreateEndpointAccessResponse CreateEndpointAccess(CreateEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Creates an Amazon Redshift Serverless managed VPC endpoint. /// /// Container for the necessary parameters to execute the CreateEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateEndpointAccessAsync(CreateEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateNamespace internal virtual CreateNamespaceResponse CreateNamespace(CreateNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Creates a namespace in Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the CreateNamespace service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateNamespaceAsync(CreateNamespaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateNamespaceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateSnapshot internal virtual CreateSnapshotResponse CreateSnapshot(CreateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Creates a snapshot of 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the CreateSnapshot service method, as returned by 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 Task CreateSnapshotAsync(CreateSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateUsageLimit internal virtual CreateUsageLimitResponse CreateUsageLimit(CreateUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateUsageLimitAsync(CreateUsageLimitRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateUsageLimitResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region CreateWorkgroup internal virtual CreateWorkgroupResponse CreateWorkgroup(CreateWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Creates an workgroup in Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the CreateWorkgroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task CreateWorkgroupAsync(CreateWorkgroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = CreateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = CreateWorkgroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteEndpointAccess internal virtual DeleteEndpointAccessResponse DeleteEndpointAccess(DeleteEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes an Amazon Redshift Serverless managed VPC endpoint. /// /// Container for the necessary parameters to execute the DeleteEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteEndpointAccessAsync(DeleteEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteNamespace internal virtual DeleteNamespaceResponse DeleteNamespace(DeleteNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteNamespaceAsync(DeleteNamespaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteNamespaceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteResourcePolicy internal virtual DeleteResourcePolicyResponse DeleteResourcePolicy(DeleteResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes the specified resource policy. /// /// Container for the necessary parameters to execute the DeleteResourcePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteResourcePolicyAsync(DeleteResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteSnapshot internal virtual DeleteSnapshotResponse DeleteSnapshot(DeleteSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes a snapshot from Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the DeleteSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the DeleteSnapshot service method, as returned by 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 Task DeleteSnapshotAsync(DeleteSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteUsageLimit internal virtual DeleteUsageLimitResponse DeleteUsageLimit(DeleteUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes a usage limit from Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the DeleteUsageLimit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteUsageLimitAsync(DeleteUsageLimitRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteUsageLimitResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region DeleteWorkgroup internal virtual DeleteWorkgroupResponse DeleteWorkgroup(DeleteWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Deletes a workgroup. /// /// Container for the necessary parameters to execute the DeleteWorkgroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task DeleteWorkgroupAsync(DeleteWorkgroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = DeleteWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = DeleteWorkgroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetCredentials internal virtual GetCredentialsResponse GetCredentials(GetCredentialsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCredentialsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetCredentialsAsync(GetCredentialsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetCredentialsRequestMarshaller.Instance; options.ResponseUnmarshaller = GetCredentialsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetEndpointAccess internal virtual GetEndpointAccessResponse GetEndpointAccess(GetEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information, such as the name, about a VPC endpoint. /// /// Container for the necessary parameters to execute the GetEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetEndpointAccessAsync(GetEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = GetEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetNamespace internal virtual GetNamespaceResponse GetNamespace(GetNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a namespace in Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the GetNamespace service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetNamespaceAsync(GetNamespaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = GetNamespaceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetRecoveryPoint internal virtual GetRecoveryPointResponse GetRecoveryPoint(GetRecoveryPointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRecoveryPointResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a recovery point. /// /// Container for the necessary parameters to execute the GetRecoveryPoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetRecoveryPointAsync(GetRecoveryPointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = GetRecoveryPointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetResourcePolicy internal virtual GetResourcePolicyResponse GetResourcePolicy(GetResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns a resource policy. /// /// Container for the necessary parameters to execute the GetResourcePolicy service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetResourcePolicyAsync(GetResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = GetResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetSnapshot internal virtual GetSnapshotResponse GetSnapshot(GetSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a specific snapshot. /// /// Container for the necessary parameters to execute the GetSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetSnapshotAsync(GetSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = GetSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetTableRestoreStatus internal virtual GetTableRestoreStatusResponse GetTableRestoreStatus(GetTableRestoreStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTableRestoreStatusResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a TableRestoreStatus object. /// /// Container for the necessary parameters to execute the GetTableRestoreStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetTableRestoreStatusAsync(GetTableRestoreStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = GetTableRestoreStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetUsageLimit internal virtual GetUsageLimitResponse GetUsageLimit(GetUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = GetUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a usage limit. /// /// Container for the necessary parameters to execute the GetUsageLimit service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetUsageLimitAsync(GetUsageLimitRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = GetUsageLimitResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region GetWorkgroup internal virtual GetWorkgroupResponse GetWorkgroup(GetWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a specific workgroup. /// /// Container for the necessary parameters to execute the GetWorkgroup service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task GetWorkgroupAsync(GetWorkgroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = GetWorkgroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListEndpointAccess internal virtual ListEndpointAccessResponse ListEndpointAccess(ListEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns an array of EndpointAccess objects and relevant information. /// /// Container for the necessary parameters to execute the ListEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListEndpointAccessAsync(ListEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = ListEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListNamespaces internal virtual ListNamespacesResponse ListNamespaces(ListNamespacesRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListNamespacesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNamespacesResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a list of specified namespaces. /// /// Container for the necessary parameters to execute the ListNamespaces service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListNamespacesAsync(ListNamespacesRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListNamespacesRequestMarshaller.Instance; options.ResponseUnmarshaller = ListNamespacesResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListRecoveryPoints internal virtual ListRecoveryPointsResponse ListRecoveryPoints(ListRecoveryPointsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListRecoveryPointsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRecoveryPointsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns an array of recovery points. /// /// Container for the necessary parameters to execute the ListRecoveryPoints service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListRecoveryPointsAsync(ListRecoveryPointsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListRecoveryPointsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListRecoveryPointsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListSnapshots internal virtual ListSnapshotsResponse ListSnapshots(ListSnapshotsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSnapshotsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns a list of snapshots. /// /// Container for the necessary parameters to execute the ListSnapshots service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListSnapshotsAsync(ListSnapshotsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListSnapshotsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListSnapshotsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTableRestoreStatus internal virtual ListTableRestoreStatusResponse ListTableRestoreStatus(ListTableRestoreStatusRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTableRestoreStatusResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about an array of TableRestoreStatus objects. /// /// Container for the necessary parameters to execute the ListTableRestoreStatus service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListTableRestoreStatusAsync(ListTableRestoreStatusRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTableRestoreStatusRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTableRestoreStatusResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListTagsForResource internal virtual ListTagsForResourceResponse ListTagsForResource(ListTagsForResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Lists the tags assigned to a resource. /// /// Container for the necessary parameters to execute the ListTagsForResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the ListTagsForResource service method, as returned by 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 Task ListTagsForResourceAsync(ListTagsForResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListTagsForResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = ListTagsForResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListUsageLimits internal virtual ListUsageLimitsResponse ListUsageLimits(ListUsageLimitsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListUsageLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListUsageLimitsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Lists all usage limits within Amazon Redshift Serverless. /// /// Container for the necessary parameters to execute the ListUsageLimits service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListUsageLimitsAsync(ListUsageLimitsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListUsageLimitsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListUsageLimitsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region ListWorkgroups internal virtual ListWorkgroupsResponse ListWorkgroups(ListWorkgroupsRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkgroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkgroupsResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Returns information about a list of specified workgroups. /// /// Container for the necessary parameters to execute the ListWorkgroups service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task ListWorkgroupsAsync(ListWorkgroupsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = ListWorkgroupsRequestMarshaller.Instance; options.ResponseUnmarshaller = ListWorkgroupsResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region PutResourcePolicy internal virtual PutResourcePolicyResponse PutResourcePolicy(PutResourcePolicyRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task PutResourcePolicyAsync(PutResourcePolicyRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = PutResourcePolicyRequestMarshaller.Instance; options.ResponseUnmarshaller = PutResourcePolicyResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreFromRecoveryPoint internal virtual RestoreFromRecoveryPointResponse RestoreFromRecoveryPoint(RestoreFromRecoveryPointRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromRecoveryPointResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Restore the data from a recovery point. /// /// Container for the necessary parameters to execute the RestoreFromRecoveryPoint service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RestoreFromRecoveryPointAsync(RestoreFromRecoveryPointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromRecoveryPointRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromRecoveryPointResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreFromSnapshot internal virtual RestoreFromSnapshotResponse RestoreFromSnapshot(RestoreFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Restores a namespace from a snapshot. /// /// Container for the necessary parameters to execute the RestoreFromSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// The response from the RestoreFromSnapshot service method, as returned by 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 Task RestoreFromSnapshotAsync(RestoreFromSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreFromSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region RestoreTableFromSnapshot internal virtual RestoreTableFromSnapshotResponse RestoreTableFromSnapshot(RestoreTableFromSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreTableFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreTableFromSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task RestoreTableFromSnapshotAsync(RestoreTableFromSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = RestoreTableFromSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = RestoreTableFromSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region TagResource internal virtual TagResourceResponse TagResource(TagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Assigns one or more tags to a resource. /// /// Container for the necessary parameters to execute the TagResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task TagResourceAsync(TagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = TagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = TagResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UntagResource internal virtual UntagResourceResponse UntagResource(UntagResourceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Removes a tag or set of tags from a resource. /// /// Container for the necessary parameters to execute the UntagResource service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UntagResourceAsync(UntagResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UntagResourceRequestMarshaller.Instance; options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateEndpointAccess internal virtual UpdateEndpointAccessResponse UpdateEndpointAccess(UpdateEndpointAccessRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateEndpointAccessResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Updates an Amazon Redshift Serverless managed endpoint. /// /// Container for the necessary parameters to execute the UpdateEndpointAccess service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateEndpointAccessAsync(UpdateEndpointAccessRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateEndpointAccessRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateEndpointAccessResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateNamespace internal virtual UpdateNamespaceResponse UpdateNamespace(UpdateNamespaceRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNamespaceResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateNamespaceAsync(UpdateNamespaceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateNamespaceRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateNamespaceResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateSnapshot internal virtual UpdateSnapshotResponse UpdateSnapshot(UpdateSnapshotRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSnapshotResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// Updates a snapshot. /// /// Container for the necessary parameters to execute the UpdateSnapshot service method. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateSnapshotAsync(UpdateSnapshotRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateSnapshotRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateSnapshotResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateUsageLimit internal virtual UpdateUsageLimitResponse UpdateUsageLimit(UpdateUsageLimitRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUsageLimitResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateUsageLimitAsync(UpdateUsageLimitRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUsageLimitRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUsageLimitResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion #region UpdateWorkgroup internal virtual UpdateWorkgroupResponse UpdateWorkgroup(UpdateWorkgroupRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkgroupResponseUnmarshaller.Instance; return Invoke(request, options); } /// /// 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. /// /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// /// /// 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 Task UpdateWorkgroupAsync(UpdateWorkgroupRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateWorkgroupRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateWorkgroupResponseUnmarshaller.Instance; return InvokeAsync(request, options, cancellationToken); } #endregion } }