Class: Aws::Keyspaces::Client

Inherits:
Seahorse::Client::Base
  • Object
show all
Includes:
ClientStubs
Defined in:
lib/aws-sdk-keyspaces/client.rb,
sig/client.rbs

Overview

An API client for Keyspaces. To construct a client, you need to configure a :region and :credentials.

client = Aws::Keyspaces::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the developer guide.

See #initialize for a full list of supported configuration options.

Defined Under Namespace

Modules: _CreateKeyspaceResponseSuccess, _CreateTableResponseSuccess, _CreateTypeResponseSuccess, _DeleteKeyspaceResponseSuccess, _DeleteTableResponseSuccess, _DeleteTypeResponseSuccess, _GetKeyspaceResponseSuccess, _GetTableAutoScalingSettingsResponseSuccess, _GetTableResponseSuccess, _GetTypeResponseSuccess, _ListKeyspacesResponseSuccess, _ListTablesResponseSuccess, _ListTagsForResourceResponseSuccess, _ListTypesResponseSuccess, _RestoreTableResponseSuccess, _TagResourceResponseSuccess, _UntagResourceResponseSuccess, _UpdateKeyspaceResponseSuccess, _UpdateTableResponseSuccess

Constant Summary collapse

Params =

Returns:

  • (:replica_specification) 

      
    

  




  
Class Attribute Summary collapse

  




  
    

      API Operations
      collapse
    


    
    
  
    

      Class Method Summary
      collapse
    


    
    
  
    

      Instance Method Summary
      collapse
    


    
    
  


  
  

  
Constructor Details

  
    

  

  
    #initialize(options)  ⇒ Client 
  

  

  




  

    
Returns a new instance of Client.


  





  
  

  

    

  





  
Parameters:


    
  
    
  • 
      
        options
      
      
        (Hash)
      
      
      
    
    • 
  



  
    
    
    
Options Hash (options):

    
    
      
        
  • 
          :plugins
          (Array<Seahorse::Client::Plugin>)
          
            
              — default:
              []]
            
          
          
            — 
    A list of plugins to apply to the client. Each plugin is either a
class name or an instance of a plugin class.
    
          
        
    • 
      
        
  • 
          :credentials
          (required, Aws::CredentialProvider)
          
            
          
          
            — 
    Your AWS credentials used for authentication. This can be any class that includes and implements
Aws::CredentialProvider, or instance of any one of the following classes:
    

      

    • 

      Aws::Credentials - Used for configuring static, non-refreshing
credentials.
      

      • 

    • 

      Aws::SharedCredentials - Used for loading static credentials from a
shared file, such as ~/.aws/config.
      

      • 

    • 

      Aws::AssumeRoleCredentials - Used when you need to assume a role.
      

      • 

    • 

      Aws::AssumeRoleWebIdentityCredentials - Used when you need to
assume a role after providing credentials via the web.
      

      • 

    • 

      Aws::SSOCredentials - Used for loading credentials from AWS SSO using an
access token generated from aws login.
      

      • 

    • 

      Aws::ProcessCredentials - Used for loading credentials from a
process that outputs to stdout.
      

      • 

    • 

      Aws::InstanceProfileCredentials - Used for loading credentials
from an EC2 IMDS on an EC2 instance.
      

      • 

    • 

      Aws::ECSCredentials - Used for loading credentials from
instances running in ECS.
      

      • 

    • 

      Aws::CognitoIdentityCredentials - Used for loading credentials
from the Cognito Identity service.
      

      • 

    

    When :credentials are not configured directly, the following locations will be searched for credentials:
    

      

    • 

      Aws.config[:credentials]
      

      • 

    • 

      The :access_key_id, :secret_access_key, :session_token, and
:account_id options.
      

      • 

    • 

      ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'],
ENV['AWS_SESSION_TOKEN'], and ENV['AWS_ACCOUNT_ID'].
      

      • 

    • 

      ~/.aws/credentials
      

      • 

    • 

      ~/.aws/config
      

      • 

    • 

      EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive.
Construct and pass an instance of Aws::InstanceProfileCredentials or Aws::ECSCredentials to
enable retries and extended timeouts. Instance profile credential fetching can be disabled by
setting ENV['AWS_EC2_METADATA_DISABLED'] to true.
      

      • 

    
          
        
    • 
      
        
  • 
          :region
          (required, String)
          
            
          
          
            — 
    The AWS region to connect to.  The configured :region is
used to determine the service :endpoint. When not passed,
a default :region is searched for in the following locations:
    

      

    • Aws.config[:region]
      • 

    • ENV['AWS_REGION']
      • 

    • ENV['AMAZON_REGION']
      • 

    • ENV['AWS_DEFAULT_REGION']
      • 

    • ~/.aws/credentials
      • 

    • ~/.aws/config
      • 

    
          
        
    • 
      
        
  • 
          :access_key_id
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :account_id
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :active_endpoint_cache
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When set to true, a thread polling for endpoints will be running in
the background every 60 secs (default). Defaults to false.
    
          
        
    • 
      
        
  • 
          :adaptive_retry_wait_to_fill
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    Used only in adaptive retry mode.  When true, the request will sleep
until there is sufficent client side capacity to retry the request.
When false, the request will raise a RetryCapacityNotAvailableError and will
not retry instead of sleeping.
    
          
        
    • 
      
        
  • 
          :auth_scheme_preference
          (Array<String>)
          
            
          
          
            — 
    A list of preferred authentication schemes to use when making a request. Supported values are:
sigv4, sigv4a, httpBearerAuth, and noAuth. When set using ENV['AWS_AUTH_SCHEME_PREFERENCE'] or in
shared config as auth_scheme_preference, the value should be a comma-separated list.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When true, client-side metrics will be collected for all API requests from
this client.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_client_id
          (String)
          
            
              — default:
              ""
            
          
          
            — 
    Allows you to provide an identifier for this client which will be attached to
all generated client side metrics. Defaults to an empty string.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_host
          (String)
          
            
              — default:
              "127.0.0.1"
            
          
          
            — 
    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client
side monitoring agent is running on, where client metrics will be published via UDP.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_port
          (Integer)
          
            
              — default:
              31000
            
          
          
            — 
    Required for publishing client metrics. The port that the client side monitoring
agent is running on, where client metrics will be published via UDP.
    
          
        
    • 
      
        
  • 
          :client_side_monitoring_publisher
          (Aws::ClientSideMonitoring::Publisher)
          
            
              — default:
              Aws::ClientSideMonitoring::Publisher
            
          
          
            — 
    Allows you to provide a custom client-side monitoring publisher class. By default,
will use the Client Side Monitoring Agent Publisher.
    
          
        
    • 
      
        
  • 
          :convert_params
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    When true, an attempt is made to coerce request parameters into
the required types.
    
          
        
    • 
      
        
  • 
          :correct_clock_skew
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    Used only in standard and adaptive retry modes. Specifies whether to apply
a clock skew correction and retry requests with skewed client clocks.
    
          
        
    • 
      
        
  • 
          :defaults_mode
          (String)
          
            
              — default:
              "legacy"
            
          
          
            — 
    See DefaultsModeConfiguration for a list of the
accepted modes and the configuration defaults that are included.
    
          
        
    • 
      
        
  • 
          :disable_host_prefix_injection
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When true, the SDK will not prepend the modeled host prefix to the endpoint.
    
          
        
    • 
      
        
  • 
          :disable_request_compression
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When set to 'true' the request body will not be compressed
for supported operations.
    
          
        
    • 
      
        
  • 
          :endpoint
          (String, URI::HTTPS, URI::HTTP)
          
            
          
          
            — 
    Normally you should not configure the :endpoint option
directly. This is normally constructed from the :region
option. Configuring :endpoint is normally reserved for
connecting to test or custom endpoints. The endpoint should
be a URI formatted like:
    

    'http://example.com'
'https://example.com'
'http://example.com:123'
    
          
        
    • 
      
        
  • 
          :endpoint_cache_max_entries
          (Integer)
          
            
              — default:
              1000
            
          
          
            — 
    Used for the maximum size limit of the LRU cache storing endpoints data
for endpoint discovery enabled operations. Defaults to 1000.
    
          
        
    • 
      
        
  • 
          :endpoint_cache_max_threads
          (Integer)
          
            
              — default:
              10
            
          
          
            — 
    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.
    
          
        
    • 
      
        
  • 
          :endpoint_cache_poll_interval
          (Integer)
          
            
              — default:
              60
            
          
          
            — 
    When :endpoint_discovery and :active_endpoint_cache is enabled,
Use this option to config the time interval in seconds for making
requests fetching endpoints information. Defaults to 60 sec.
    
          
        
    • 
      
        
  • 
          :endpoint_discovery
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When set to true, endpoint discovery will be enabled for operations when available.
    
          
        
    • 
      
        
  • 
          :ignore_configured_endpoint_urls
          (Boolean)
          
            
          
          
            — 
    Setting to true disables use of endpoint URLs provided via environment
variables and the shared configuration file.
    
          
        
    • 
      
        
  • 
          :log_formatter
          (Aws::Log::Formatter)
          
            
              — default:
              Aws::Log::Formatter.default
            
          
          
            — 
    The log formatter.
    
          
        
    • 
      
        
  • 
          :log_level
          (Symbol)
          
            
              — default:
              :info
            
          
          
            — 
    The log level to send messages to the :logger at.
    
          
        
    • 
      
        
  • 
          :logger
          (Logger)
          
            
          
          
            — 
    The Logger instance to send log messages to.  If this option
is not set, logging will be disabled.
    
          
        
    • 
      
        
  • 
          :max_attempts
          (Integer)
          
            
              — default:
              3
            
          
          
            — 
    An integer representing the maximum number attempts that will be made for
a single request, including the initial attempt.  For example,
setting this value to 5 will result in a request being retried up to
4 times. Used in standard and adaptive retry modes.
    
          
        
    • 
      
        
  • 
          :profile
          (String)
          
            
              — default:
              "default"
            
          
          
            — 
    Used when loading credentials from the shared credentials file at HOME/.aws/credentials.
When not specified, 'default' is used.
    
          
        
    • 
      
        
  • 
          :request_checksum_calculation
          (String)
          
            
              — default:
              "when_supported"
            
          
          
            — 
    Determines when a checksum will be calculated for request payloads. Values are:
    

      

    • when_supported - (default) When set, a checksum will be
calculated for all request payloads of operations modeled with the
httpChecksum trait where requestChecksumRequired is true and/or a
requestAlgorithmMember is modeled.
      • 

    • when_required - When set, a checksum will only be calculated for
request payloads of operations modeled with the  httpChecksum trait where
requestChecksumRequired is true or where a requestAlgorithmMember
is modeled and supplied.
      • 

    
          
        
    • 
      
        
  • 
          :request_min_compression_size_bytes
          (Integer)
          
            
              — default:
              10240
            
          
          
            — 
    The minimum size in bytes that triggers compression for request
bodies. The value must be non-negative integer value between 0
and 10485780 bytes inclusive.
    
          
        
    • 
      
        
  • 
          :response_checksum_validation
          (String)
          
            
              — default:
              "when_supported"
            
          
          
            — 
    Determines when checksum validation will be performed on response payloads. Values are:
    

      

    • when_supported - (default) When set, checksum validation is performed on all
response payloads of operations modeled with the httpChecksum trait where
responseAlgorithms is modeled, except when no modeled checksum algorithms
are supported.
      • 

    • when_required - When set, checksum validation is not performed on
response payloads of operations unless the checksum algorithm is supported and
the requestValidationModeMember member is set to ENABLED.
      • 

    
          
        
    • 
      
        
  • 
          :retry_backoff
          (Proc)
          
            
          
          
            — 
    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay.
This option is only used in the legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_base_delay
          (Float)
          
            
              — default:
              0.3
            
          
          
            — 
    The base delay in seconds used by the default backoff function. This option
is only used in the legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_jitter
          (Symbol)
          
            
              — default:
              :none
            
          
          
            — 
    A delay randomiser function used by the default backoff function.
Some predefined functions can be referenced by name - :none, :equal, :full,
otherwise a Proc that takes and returns a number. This option is only used
in the legacy retry mode.
    

    @see https://www.awsarchitectureblog.com/2015/03/backoff.html
    
          
        
    • 
      
        
  • 
          :retry_limit
          (Integer)
          
            
              — default:
              3
            
          
          
            — 
    The maximum number of times to retry failed requests.  Only
~ 500 level server errors and certain ~ 400 level client errors
are retried.  Generally, these are throttling errors, data
checksum errors, networking errors, timeout errors, auth errors,
endpoint discovery, and errors from expired credentials.
This option is only used in the legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_max_delay
          (Integer)
          
            
              — default:
              0
            
          
          
            — 
    The maximum number of seconds to delay between retries (0 for no limit)
used by the default backoff function. This option is only used in the
legacy retry mode.
    
          
        
    • 
      
        
  • 
          :retry_mode
          (String)
          
            
              — default:
              "legacy"
            
          
          
            — 
    Specifies which retry algorithm to use. Values are:
    

      

    • 

      legacy - The pre-existing retry behavior. This is the default
value if no retry mode is provided.
      

      • 

    • 

      standard - A standardized set of retry rules across the AWS SDKs.
This includes support for retry quotas, which limit the number of
unsuccessful retries a client can make.
      

      • 

    • 

      adaptive - A retry mode that includes all the functionality of
standard mode along with automatic client side throttling.
      

      • 

    
          
        
    • 
      
        
  • 
          :sdk_ua_app_id
          (String)
          
            
          
          
            — 
    A unique and opaque application ID that is appended to the
User-Agent header as app/sdk_ua_app_id. It should have a
maximum length of 50. This variable is sourced from environment
variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.
    
          
        
    • 
      
        
  • 
          :secret_access_key
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :session_token
          (String)
          
            
          
          
        
    • 
      
        
  • 
          :sigv4a_signing_region_set
          (Array)
          
            
          
          
            — 
    A list of regions that should be signed with SigV4a signing. When
not passed, a default :sigv4a_signing_region_set is searched for
in the following locations:
    

      

    • Aws.config[:sigv4a_signing_region_set]
      • 

    • ENV['AWS_SIGV4A_SIGNING_REGION_SET']
      • 

    • ~/.aws/config
      • 

    
          
        
    • 
      
        
  • 
          :simple_json
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    Disables request parameter conversion, validation, and formatting.
Also disables response data type conversions. The request parameters
hash must be formatted exactly as the API expects.This option is useful
when you want to ensure the highest level of performance by avoiding
overhead of walking request parameters and response data structures.
    
          
        
    • 
      
        
  • 
          :stub_responses
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    Causes the client to return stubbed responses. By default
fake responses are generated and returned. You can specify
the response data to return or errors to raise by calling
ClientStubs#stub_responses. See ClientStubs for more information.
    

    ** Please note ** When response stubbing is enabled, no HTTP
requests are made, and retries are disabled.
    
          
        
    • 
      
        
  • 
          :telemetry_provider
          (Aws::Telemetry::TelemetryProviderBase)
          
            
              — default:
              Aws::Telemetry::NoOpTelemetryProvider
            
          
          
            — 
    Allows you to provide a telemetry provider, which is used to
emit telemetry data. By default, uses NoOpTelemetryProvider which
will not record or emit any telemetry data. The SDK supports the
following telemetry providers:
    

      

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the
opentelemetry-sdk gem and then, pass in an instance of a
Aws::Telemetry::OTelProvider for telemetry provider.
      • 

    
          
        
    • 
      
        
  • 
          :token_provider
          (Aws::TokenProvider)
          
            
          
          
            — 
    Your Bearer token used for authentication. This can be any class that includes and implements
Aws::TokenProvider, or instance of any one of the following classes:
    

      

    • 

      Aws::StaticTokenProvider - Used for configuring static, non-refreshing
tokens.
      

      • 

    • 

      Aws::SSOTokenProvider - Used for loading tokens from AWS SSO using an
access token generated from aws login.
      

      • 

    

    When :token_provider is not configured directly, the Aws::TokenProviderChain
will be used to search for tokens configured for your profile in shared configuration files.
    
          
        
    • 
      
        
  • 
          :use_dualstack_endpoint
          (Boolean)
          
            
          
          
            — 
    When set to true, dualstack enabled endpoints (with .aws TLD)
will be used if available.
    
          
        
    • 
      
        
  • 
          :use_fips_endpoint
          (Boolean)
          
            
          
          
            — 
    When set to true, fips compatible endpoints will be used if available.
When a fips region is used, the region is normalized and this config
is set to true.
    
          
        
    • 
      
        
  • 
          :validate_params
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    When true, request parameters are validated before
sending the request.
    
          
        
    • 
      
        
  • 
          :endpoint_provider
          (Aws::Keyspaces::EndpointProvider)
          
            
          
          
            — 
    The endpoint provider used to resolve endpoints. Any object that responds to
#resolve_endpoint(parameters) where parameters is a Struct similar to
Aws::Keyspaces::EndpointParameters.
    
          
        
    • 
      
        
  • 
          :http_continue_timeout
          (Float)
          
            
              — default:
              1
            
          
          
            — 
    The number of seconds to wait for a 100-continue response before sending the
request body.  This option has no effect unless the request has "Expect"
header set to "100-continue".  Defaults to nil which  disables this
behaviour.  This value can safely be set per request on the session.
    
          
        
    • 
      
        
  • 
          :http_idle_timeout
          (Float)
          
            
              — default:
              5
            
          
          
            — 
    The number of seconds a connection is allowed to sit idle before it
is considered stale.  Stale connections are closed and removed from the
pool before making a request.
    
          
        
    • 
      
        
  • 
          :http_open_timeout
          (Float)
          
            
              — default:
              15
            
          
          
            — 
    The default number of seconds to wait for response data.
This value can safely be set per-request on the session.
    
          
        
    • 
      
        
  • 
          :http_proxy
          (URI::HTTP, String)
          
            
          
          
            — 
    A proxy to send requests through.  Formatted like 'http://proxy.com:123'.
    
          
        
    • 
      
        
  • 
          :http_read_timeout
          (Float)
          
            
              — default:
              60
            
          
          
            — 
    The default number of seconds to wait for response data.
This value can safely be set per-request on the session.
    
          
        
    • 
      
        
  • 
          :http_wire_trace
          (Boolean)
          
            
              — default:
              false
            
          
          
            — 
    When true,  HTTP debug output will be sent to the :logger.
    
          
        
    • 
      
        
  • 
          :on_chunk_received
          (Proc)
          
            
          
          
            — 
    When a Proc object is provided, it will be used as callback when each chunk
of the response body is received. It provides three arguments: the chunk,
the number of bytes received, and the total number of
bytes in the response (or nil if the server did not send a content-length).
    
          
        
    • 
      
        
  • 
          :on_chunk_sent
          (Proc)
          
            
          
          
            — 
    When a Proc object is provided, it will be used as callback when each chunk
of the request body is sent. It provides three arguments: the chunk,
the number of bytes read from the body, and the total number of
bytes in the body.
    
          
        
    • 
      
        
  • 
          :raise_response_errors
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    When true, response errors are raised.
    
          
        
    • 
      
        
  • 
          :ssl_ca_bundle
          (String)
          
            
          
          
            — 
    Full path to the SSL certificate authority bundle file that should be used when
verifying peer certificates.  If you do not pass :ssl_ca_bundle or
:ssl_ca_directory the the system default will be used if available.
    
          
        
    • 
      
        
  • 
          :ssl_ca_directory
          (String)
          
            
          
          
            — 
    Full path of the directory that contains the unbundled SSL certificate
authority files for verifying peer certificates.  If you do
not pass :ssl_ca_bundle or :ssl_ca_directory the the system
default will be used if available.
    
          
        
    • 
      
        
  • 
          :ssl_ca_store
          (String)
          
            
          
          
            — 
    Sets the X509::Store to verify peer certificate.
    
          
        
    • 
      
        
  • 
          :ssl_cert
          (OpenSSL::X509::Certificate)
          
            
          
          
            — 
    Sets a client certificate when creating http connections.
    
          
        
    • 
      
        
  • 
          :ssl_key
          (OpenSSL::PKey)
          
            
          
          
            — 
    Sets a client key when creating http connections.
    
          
        
    • 
      
        
  • 
          :ssl_timeout
          (Float)
          
            
          
          
            — 
    Sets the SSL timeout in seconds
    
          
        
    • 
      
        
  • 
          :ssl_verify_peer
          (Boolean)
          
            
              — default:
              true
            
          
          
            — 
    When true, SSL peer certificates are verified when establishing a connection.
    
          
        
    • 
      
    

  








  

    
      


478
479
480

    		
    
      
# File 'lib/aws-sdk-keyspaces/client.rb', line 478

def initialize(*args)
  super
end

    		
  





  



  

    
Class Attribute Details

    
      
      
      

  

  
    .identifier  ⇒ Object  (readonly)
  

  

  




  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.




  





  



  

    
      


2312
2313
2314

    		
    
      
# File 'lib/aws-sdk-keyspaces/client.rb', line 2312

def identifier
  @identifier
end

    		
  





    
  



  

    
Class Method Details


    
      

  

  
    .errors_module  ⇒ Object 
  

  

  




  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.




  





  



  

    
      


2315
2316
2317

    		
    
      
# File 'lib/aws-sdk-keyspaces/client.rb', line 2315

def errors_module
  Errors
end

    		
  





    
      

  

  
    .new  ⇒ Object 
  

  

  




  

    
https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/Keyspaces/Client.html#initialize-instance_method


  





  



  

    
      


14

    		
    
      
# File 'sig/client.rbs', line 14

def self.new: (

    		
  





    
  


  

    
Instance Method Details


    
      

  

  
    #build_request(operation_name, params = {})  ⇒ Object 
  

  

  




  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.




  





  
Parameters:


    
  
    
  • 
      
        params
      
      
        ({})
      
      
        (defaults to: {})
      
      
    
    • 
  






  

    
      


2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301

    		
    
      
# File 'lib/aws-sdk-keyspaces/client.rb', line 2285

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  tracer = config.telemetry_provider.tracer_provider.tracer(
    Aws::Telemetry.module_to_tracer_name('Aws::Keyspaces')
  )
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config,
    tracer: tracer
  )
  context[:gem_name] = 'aws-sdk-keyspaces'
  context[:gem_version] = '1.62.0'
  Seahorse::Client::Request.new(handlers, context)
end

    		
  





    
      

  

  
    #create_keyspace(params = {})  ⇒ Types::CreateKeyspaceResponse 
  

  

  




  

    
The CreateKeyspace operation adds a new keyspace to your account. In
an Amazon Web Services account, keyspace names must be unique within
each Region.


CreateKeyspace is an asynchronous operation. You can monitor the
creation status of the new keyspace by using the GetKeyspace
operation.


For more information, see Create a keyspace in the Amazon
Keyspaces Developer Guide.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.create_keyspace({
  keyspace_name: "KeyspaceName", # required
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  replication_specification: {
    replication_strategy: "SINGLE_REGION", # required, accepts SINGLE_REGION, MULTI_REGION
    region_list: ["region"],
  },
})

    
      
        
Response structure

      
      

resp.resource_arn #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace to be created.
    
          
        
    • 
      
        
  • 
          :tags
          (Array<Types::Tag>)
          
            
          
          
            — 
    A list of key-value pair tags to be attached to the keyspace.
    

    For more information, see Adding tags and labels to Amazon Keyspaces
resources in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :replication_specification
          (Types::ReplicationSpecification)
          
            
          
          
            — 
    The replication specification of the keyspace includes:
    

      

    • 

      replicationStrategy - the required value is SINGLE_REGION or
MULTI_REGION.
      

      • 

    • 

      regionList - if the replicationStrategy is MULTI_REGION, the
regionList requires the current Region and at least one additional
Amazon Web Services Region where the keyspace is going to be
replicated in.
      

      • 

    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


87

    		
    
      
# File 'sig/client.rbs', line 87

def create_keyspace: (

    		
  





    
      

  

  
    #create_table(params = {})  ⇒ Types::CreateTableResponse 
  

  

  




  

    
The CreateTable operation adds a new table to the specified
keyspace. Within a keyspace, table names must be unique.


CreateTable is an asynchronous operation. When the request is
received, the status of the table is set to CREATING. You can
monitor the creation status of the new table by using the GetTable
operation, which returns the current status of the table. You can
start using a table when the status is ACTIVE.


For more information, see Create a table in the Amazon Keyspaces
Developer Guide.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.create_table({
  keyspace_name: "KeyspaceName", # required
  table_name: "TableName", # required
  schema_definition: { # required
    all_columns: [ # required
      {
        name: "GenericString", # required
        type: "GenericString", # required
      },
    ],
    partition_keys: [ # required
      {
        name: "GenericString", # required
      },
    ],
    clustering_keys: [
      {
        name: "GenericString", # required
        order_by: "ASC", # required, accepts ASC, DESC
      },
    ],
    static_columns: [
      {
        name: "GenericString", # required
      },
    ],
  },
  comment: {
    message: "String", # required
  },
  capacity_specification: {
    throughput_mode: "PAY_PER_REQUEST", # required, accepts PAY_PER_REQUEST, PROVISIONED
    read_capacity_units: 1,
    write_capacity_units: 1,
  },
  encryption_specification: {
    type: "CUSTOMER_MANAGED_KMS_KEY", # required, accepts CUSTOMER_MANAGED_KMS_KEY, AWS_OWNED_KMS_KEY
    kms_key_identifier: "kmsKeyARN",
  },
  point_in_time_recovery: {
    status: "ENABLED", # required, accepts ENABLED, DISABLED
  },
  ttl: {
    status: "ENABLED", # required, accepts ENABLED
  },
  default_time_to_live: 1,
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  client_side_timestamps: {
    status: "ENABLED", # required, accepts ENABLED
  },
  auto_scaling_specification: {
    write_capacity_auto_scaling: {
      auto_scaling_disabled: false,
      minimum_units: 1,
      maximum_units: 1,
      scaling_policy: {
        target_tracking_scaling_policy_configuration: {
          disable_scale_in: false,
          scale_in_cooldown: 1,
          scale_out_cooldown: 1,
          target_value: 1.0, # required
        },
      },
    },
    read_capacity_auto_scaling: {
      auto_scaling_disabled: false,
      minimum_units: 1,
      maximum_units: 1,
      scaling_policy: {
        target_tracking_scaling_policy_configuration: {
          disable_scale_in: false,
          scale_in_cooldown: 1,
          scale_out_cooldown: 1,
          target_value: 1.0, # required
        },
      },
    },
  },
  replica_specifications: [
    {
      region: "region", # required
      read_capacity_units: 1,
      read_capacity_auto_scaling: {
        auto_scaling_disabled: false,
        minimum_units: 1,
        maximum_units: 1,
        scaling_policy: {
          target_tracking_scaling_policy_configuration: {
            disable_scale_in: false,
            scale_in_cooldown: 1,
            scale_out_cooldown: 1,
            target_value: 1.0, # required
          },
        },
      },
    },
  ],
  cdc_specification: {
    status: "ENABLED", # required, accepts ENABLED, ENABLING, DISABLED, DISABLING
    view_type: "NEW_IMAGE", # accepts NEW_IMAGE, OLD_IMAGE, KEYS_ONLY, NEW_AND_OLD_IMAGES
    tags: [
      {
        key: "TagKey", # required
        value: "TagValue", # required
      },
    ],
    propagate_tags: "TABLE", # accepts TABLE, NONE
  },
  warm_throughput_specification: {
    read_units_per_second: 1,
    write_units_per_second: 1,
  },
})

    
      
        
Response structure

      
      

resp.resource_arn #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace that the table is going to be created in.
    
          
        
    • 
      
        
  • 
          :table_name
          (required, String)
          
            
          
          
            — 
    The name of the table.
    
          
        
    • 
      
        
  • 
          :schema_definition
          (required, Types::SchemaDefinition)
          
            
          
          
            — 
    The schemaDefinition consists of the following parameters.
    

    For each column to be created:
    

      

    • 

      name - The name of the column.
      

      • 

    • 

      type - An Amazon Keyspaces data type. For more information, see
Data types in the Amazon Keyspaces Developer Guide.
      

      • 

    

    The primary key of the table consists of the following columns:
    

      

    • 

      partitionKeys - The partition key can be a single column, or it
can be a compound value composed of two or more columns. The
partition key portion of the primary key is required and determines
how Amazon Keyspaces stores your data.
      

      • 

    • 

      name - The name of each partition key column.
      

      • 

    • 

      clusteringKeys - The optional clustering column portion of your
primary key determines how the data is clustered and sorted within
each partition.
      

      • 

    • 

      name - The name of the clustering column.
      

      • 

    • 

      orderBy - Sets the ascendant (ASC) or descendant (DESC) order
modifier.
      

      To define a column as static use staticColumns - Static columns
store values that are shared by all rows in the same partition:
      

      • 

    • 

      name - The name of the column.
      

      • 

    • 

      type - An Amazon Keyspaces data type.
      

      • 

    
          
        
    • 
      
        
  • 
          :comment
          (Types::Comment)
          
            
          
          
            — 
    This parameter allows to enter a description of the table.
    
          
        
    • 
      
        
  • 
          :capacity_specification
          (Types::CapacitySpecification)
          
            
          
          
            — 
    Specifies the read/write throughput capacity mode for the table. The
options are:
    

      

    • 

      throughputMode:PAY_PER_REQUEST and
      

      • 

    • 

      throughputMode:PROVISIONED - Provisioned capacity mode requires
readCapacityUnits and writeCapacityUnits as input.
      

      • 

    

    The default is throughput_mode:PAY_PER_REQUEST.
    

    For more information, see Read/write capacity modes in the
Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :encryption_specification
          (Types::EncryptionSpecification)
          
            
          
          
            — 
    Specifies how the encryption key for encryption at rest is managed for
the table. You can choose one of the following KMS key (KMS key):
    

      

    • 

      type:AWS_OWNED_KMS_KEY - This key is owned by Amazon Keyspaces.
      

      • 

    • 

      type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your account
and is created, owned, and managed by you. This option requires the
kms_key_identifier of the KMS key in Amazon Resource Name (ARN)
format as input.
      

      • 

    

    The default is type:AWS_OWNED_KMS_KEY.
    

    For more information, see Encryption at rest in the Amazon
Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :point_in_time_recovery
          (Types::PointInTimeRecovery)
          
            
          
          
            — 
    Specifies if pointInTimeRecovery is enabled or disabled for the
table. The options are:
    

      

    • 

      status=ENABLED
      

      • 

    • 

      status=DISABLED
      

      • 

    

    If it's not specified, the default is status=DISABLED.
    

    For more information, see Point-in-time recovery in the Amazon
Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :ttl
          (Types::TimeToLive)
          
            
          
          
            — 
    Enables Time to Live custom settings for the table. The options are:
    

      

    • 

      status:enabled
      

      • 

    • 

      status:disabled
      

      • 

    

    The default is status:disabled. After ttl is enabled, you can't
disable it for the table.
    

    For more information, see Expiring data by using Amazon Keyspaces
Time to Live (TTL) in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :default_time_to_live
          (Integer)
          
            
          
          
            — 
    The default Time to Live setting in seconds for the table.
    

    For more information, see Setting the default TTL value for a
table in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :tags
          (Array<Types::Tag>)
          
            
          
          
            — 
    A list of key-value pair tags to be attached to the resource.
    

    For more information, see Adding tags and labels to Amazon Keyspaces
resources in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :client_side_timestamps
          (Types::ClientSideTimestamps)
          
            
          
          
            — 
    Enables client-side timestamps for the table. By default, the setting
is disabled. You can enable client-side timestamps with the following
option:
    

      

    • status: "enabled"
      • 

    

    ^
    

    Once client-side timestamps are enabled for a table, this setting
cannot be disabled.
    
          
        
    • 
      
        
  • 
          :auto_scaling_specification
          (Types::AutoScalingSpecification)
          
            
          
          
            — 
    The optional auto scaling settings for a table in provisioned capacity
mode. Specifies if the service can manage throughput capacity
automatically on your behalf.
    

    Auto scaling helps you provision throughput capacity for variable
workloads efficiently by increasing and decreasing your table's read
and write capacity automatically in response to application traffic.
For more information, see Managing throughput capacity automatically
with Amazon Keyspaces auto scaling in the Amazon Keyspaces
Developer Guide.
    

    By default, auto scaling is disabled for a table.
    
          
        
    • 
      
        
  • 
          :replica_specifications
          (Array<Types::ReplicaSpecification>)
          
            
          
          
            — 
    The optional Amazon Web Services Region specific settings of a
multi-Region table. These settings overwrite the general settings of
the table for the specified Region.
    

    For a multi-Region table in provisioned capacity mode, you can
configure the table's read capacity differently for each Region's
replica. The write capacity, however, remains synchronized between all
replicas to ensure that there's enough capacity to replicate writes
across all Regions. To define the read capacity for a table replica in
a specific Region, you can do so by configuring the following
parameters.
    

      

    • 

      region: The Region where these settings are applied. (Required)
      

      • 

    • 

      readCapacityUnits: The provisioned read capacity units. (Optional)
      

      • 

    • 

      readCapacityAutoScaling: The read capacity auto scaling settings
for the table. (Optional)
      

      • 

    
          
        
    • 
      
        
  • 
          :cdc_specification
          (Types::CdcSpecification)
          
            
          
          
            — 
    The CDC stream settings of the table.
    
          
        
    • 
      
        
  • 
          :warm_throughput_specification
          (Types::WarmThroughputSpecification)
          
            
          
          
            — 
    Specifies the warm throughput settings for the table. Pre-warming a
table helps you avoid capacity exceeded exceptions by pre-provisioning
read and write capacity units to reduce cold start latency when your
table receives traffic.
    

    For more information about pre-warming in Amazon Keyspaces, see
Pre-warm a table in Amazon Keyspaces in the Amazon Keyspaces
Developer Guide.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


107

    		
    
      
# File 'sig/client.rbs', line 107

def create_table: (

    		
  





    
      

  

  
    #create_type(params = {})  ⇒ Types::CreateTypeResponse 
  

  

  




  

    
The CreateType operation creates a new user-defined type in the
specified keyspace.


To configure the required permissions, see Permissions to create a
UDT in the Amazon Keyspaces Developer Guide.


For more information, see User-defined types (UDTs) in the
Amazon Keyspaces Developer Guide.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.create_type({
  keyspace_name: "KeyspaceName", # required
  type_name: "TypeName", # required
  field_definitions: [ # required
    {
      name: "FieldDefinitionNameString", # required
      type: "GenericString", # required
    },
  ],
})

    
      
        
Response structure

      
      

resp.keyspace_arn #=> String
resp.type_name #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace.
    
          
        
    • 
      
        
  • 
          :type_name
          (required, String)
          
            
          
          
            — 
    The name of the user-defined type.
    

    UDT names must contain 48 characters or less, must begin with an
alphabetic character, and can only contain alpha-numeric characters
and underscores. Amazon Keyspaces converts upper case characters
automatically into lower case characters.
    

    Alternatively, you can declare a UDT name in double quotes. When
declaring a UDT name inside double quotes, Amazon Keyspaces preserves
upper casing and allows special characters.
    

    You can also use double quotes as part of the name when you create the
UDT, but you must escape each double quote character with an
additional double quote character.
    
          
        
    • 
      
        
  • 
          :field_definitions
          (required, Array<Types::FieldDefinition>)
          
            
          
          
            — 
    The field definitions, consisting of names and types, that define this
type.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


180

    		
    
      
# File 'sig/client.rbs', line 180

def create_type: (

    		
  





    
      

  

  
    #delete_keyspace(params = {})  ⇒ Struct 
  

  

  




  

    
The DeleteKeyspace operation deletes a keyspace and all of its
tables.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.delete_keyspace({
  keyspace_name: "KeyspaceName", # required
})

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace to be deleted.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


196

    		
    
      
# File 'sig/client.rbs', line 196

def delete_keyspace: (

    		
  





    
      

  

  
    #delete_table(params = {})  ⇒ Struct 
  

  

  




  

    
The DeleteTable operation deletes a table and all of its data. After
a DeleteTable request is received, the specified table is in the
DELETING state until Amazon Keyspaces completes the deletion. If the
table is in the ACTIVE state, you can delete it. If a table is
either in the CREATING or UPDATING states, then Amazon Keyspaces
returns a ResourceInUseException. If the specified table does not
exist, Amazon Keyspaces returns a ResourceNotFoundException. If the
table is already in the DELETING state, no error is returned.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.delete_table({
  keyspace_name: "KeyspaceName", # required
  table_name: "TableName", # required
})

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace of the to be deleted table.
    
          
        
    • 
      
        
  • 
          :table_name
          (required, String)
          
            
          
          
            — 
    The name of the table to be deleted.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


205

    		
    
      
# File 'sig/client.rbs', line 205

def delete_table: (

    		
  





    
      

  

  
    #delete_type(params = {})  ⇒ Types::DeleteTypeResponse 
  

  

  




  

    
The DeleteType operation deletes a user-defined type (UDT). You can
only delete a type that is not used in a table or another UDT.


To configure the required permissions, see Permissions to delete a
UDT in the Amazon Keyspaces Developer Guide.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.delete_type({
  keyspace_name: "KeyspaceName", # required
  type_name: "TypeName", # required
})

    
      
        
Response structure

      
      

resp.keyspace_arn #=> String
resp.type_name #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace of the to be deleted type.
    
          
        
    • 
      
        
  • 
          :type_name
          (required, String)
          
            
          
          
            — 
    The name of the type to be deleted.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


217

    		
    
      
# File 'sig/client.rbs', line 217

def delete_type: (

    		
  





    
      

  

  
    #get_keyspace(params = {})  ⇒ Types::GetKeyspaceResponse 
  

  

  




  

    
Returns the name of the specified keyspace, the Amazon Resource Name
(ARN), the replication strategy, the Amazon Web Services Regions of a
multi-Region keyspace, and the status of newly added Regions after an
UpdateKeyspace operation.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.get_keyspace({
  keyspace_name: "KeyspaceName", # required
})

    
      
        
Response structure

      
      

resp.keyspace_name #=> String
resp.resource_arn #=> String
resp.replication_strategy #=> String, one of "SINGLE_REGION", "MULTI_REGION"
resp.replication_regions #=> Array
resp.replication_regions[0] #=> String
resp.replication_group_statuses #=> Array
resp.replication_group_statuses[0].region #=> String
resp.replication_group_statuses[0].keyspace_status #=> String, one of "ACTIVE", "CREATING", "UPDATING", "DELETING"
resp.replication_group_statuses[0].tables_replication_progress #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


232

    		
    
      
# File 'sig/client.rbs', line 232

def get_keyspace: (

    		
  





    
      

  

  
    #get_table(params = {})  ⇒ Types::GetTableResponse 
  

  

  




  

    
Returns information about the table, including the table's name and
current status, the keyspace name, configuration settings, and
metadata.


To read table metadata using GetTable, the IAM principal needs
Select action permissions for the table and the system keyspace.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.get_table({
  keyspace_name: "KeyspaceName", # required
  table_name: "TableName", # required
})

    
      
        
Response structure

      
      

resp.keyspace_name #=> String
resp.table_name #=> String
resp.resource_arn #=> String
resp.creation_timestamp #=> Time
resp.status #=> String, one of "ACTIVE", "CREATING", "UPDATING", "DELETING", "DELETED", "RESTORING", "INACCESSIBLE_ENCRYPTION_CREDENTIALS"
resp.schema_definition.all_columns #=> Array
resp.schema_definition.all_columns[0].name #=> String
resp.schema_definition.all_columns[0].type #=> String
resp.schema_definition.partition_keys #=> Array
resp.schema_definition.partition_keys[0].name #=> String
resp.schema_definition.clustering_keys #=> Array
resp.schema_definition.clustering_keys[0].name #=> String
resp.schema_definition.clustering_keys[0].order_by #=> String, one of "ASC", "DESC"
resp.schema_definition.static_columns #=> Array
resp.schema_definition.static_columns[0].name #=> String
resp.capacity_specification.throughput_mode #=> String, one of "PAY_PER_REQUEST", "PROVISIONED"
resp.capacity_specification.read_capacity_units #=> Integer
resp.capacity_specification.write_capacity_units #=> Integer
resp.capacity_specification.last_update_to_pay_per_request_timestamp #=> Time
resp.encryption_specification.type #=> String, one of "CUSTOMER_MANAGED_KMS_KEY", "AWS_OWNED_KMS_KEY"
resp.encryption_specification.kms_key_identifier #=> String
resp.point_in_time_recovery.status #=> String, one of "ENABLED", "DISABLED"
resp.point_in_time_recovery.earliest_restorable_timestamp #=> Time
resp.ttl.status #=> String, one of "ENABLED"
resp.default_time_to_live #=> Integer
resp.comment.message #=> String
resp.client_side_timestamps.status #=> String, one of "ENABLED"
resp.replica_specifications #=> Array
resp.replica_specifications[0].region #=> String
resp.replica_specifications[0].status #=> String, one of "ACTIVE", "CREATING", "UPDATING", "DELETING", "DELETED", "RESTORING", "INACCESSIBLE_ENCRYPTION_CREDENTIALS"
resp.replica_specifications[0].capacity_specification.throughput_mode #=> String, one of "PAY_PER_REQUEST", "PROVISIONED"
resp.replica_specifications[0].capacity_specification.read_capacity_units #=> Integer
resp.replica_specifications[0].capacity_specification.write_capacity_units #=> Integer
resp.replica_specifications[0].capacity_specification.last_update_to_pay_per_request_timestamp #=> Time
resp.replica_specifications[0].warm_throughput_specification.read_units_per_second #=> Integer
resp.replica_specifications[0].warm_throughput_specification.write_units_per_second #=> Integer
resp.replica_specifications[0].warm_throughput_specification.status #=> String, one of "AVAILABLE", "UPDATING"
resp.latest_stream_arn #=> String
resp.cdc_specification.status #=> String, one of "ENABLED", "ENABLING", "DISABLED", "DISABLING"
resp.cdc_specification.view_type #=> String, one of "NEW_IMAGE", "OLD_IMAGE", "KEYS_ONLY", "NEW_AND_OLD_IMAGES"
resp.warm_throughput_specification.read_units_per_second #=> Integer
resp.warm_throughput_specification.write_units_per_second #=> Integer
resp.warm_throughput_specification.status #=> String, one of "AVAILABLE", "UPDATING"

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace that the table is stored in.
    
          
        
    • 
      
        
  • 
          :table_name
          (required, String)
          
            
          
          
            — 
    The name of the table.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


258

    		
    
      
# File 'sig/client.rbs', line 258

def get_table: (

    		
  





    
      

  

  
    #get_table_auto_scaling_settings(params = {})  ⇒ Types::GetTableAutoScalingSettingsResponse 
  

  

  




  

    
Returns auto scaling related settings of the specified table in JSON
format. If the table is a multi-Region table, the Amazon Web Services
Region specific auto scaling settings of the table are included.


Amazon Keyspaces auto scaling helps you provision throughput capacity
for variable workloads efficiently by increasing and decreasing your
table's read and write capacity automatically in response to
application traffic. For more information, see Managing throughput
capacity automatically with Amazon Keyspaces auto scaling in the
Amazon Keyspaces Developer Guide.


GetTableAutoScalingSettings can't be used as an action in an IAM
policy.


To define permissions for GetTableAutoScalingSettings, you must
allow the following two actions in the IAM policy statement's
Action element:


    

  • 

    application-autoscaling:DescribeScalableTargets
    

    • 

  • 

    application-autoscaling:DescribeScalingPolicies
    

    • 



  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.get_table_auto_scaling_settings({
  keyspace_name: "KeyspaceName", # required
  table_name: "TableName", # required
})

    
      
        
Response structure

      
      

resp.keyspace_name #=> String
resp.table_name #=> String
resp.resource_arn #=> String
resp.auto_scaling_specification.write_capacity_auto_scaling.auto_scaling_disabled #=> Boolean
resp.auto_scaling_specification.write_capacity_auto_scaling.minimum_units #=> Integer
resp.auto_scaling_specification.write_capacity_auto_scaling.maximum_units #=> Integer
resp.auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.disable_scale_in #=> Boolean
resp.auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_in_cooldown #=> Integer
resp.auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_out_cooldown #=> Integer
resp.auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.target_value #=> Float
resp.auto_scaling_specification.read_capacity_auto_scaling.auto_scaling_disabled #=> Boolean
resp.auto_scaling_specification.read_capacity_auto_scaling.minimum_units #=> Integer
resp.auto_scaling_specification.read_capacity_auto_scaling.maximum_units #=> Integer
resp.auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.disable_scale_in #=> Boolean
resp.auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_in_cooldown #=> Integer
resp.auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_out_cooldown #=> Integer
resp.auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.target_value #=> Float
resp.replica_specifications #=> Array
resp.replica_specifications[0].region #=> String
resp.replica_specifications[0].auto_scaling_specification.write_capacity_auto_scaling.auto_scaling_disabled #=> Boolean
resp.replica_specifications[0].auto_scaling_specification.write_capacity_auto_scaling.minimum_units #=> Integer
resp.replica_specifications[0].auto_scaling_specification.write_capacity_auto_scaling.maximum_units #=> Integer
resp.replica_specifications[0].auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.disable_scale_in #=> Boolean
resp.replica_specifications[0].auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_in_cooldown #=> Integer
resp.replica_specifications[0].auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_out_cooldown #=> Integer
resp.replica_specifications[0].auto_scaling_specification.write_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.target_value #=> Float
resp.replica_specifications[0].auto_scaling_specification.read_capacity_auto_scaling.auto_scaling_disabled #=> Boolean
resp.replica_specifications[0].auto_scaling_specification.read_capacity_auto_scaling.minimum_units #=> Integer
resp.replica_specifications[0].auto_scaling_specification.read_capacity_auto_scaling.maximum_units #=> Integer
resp.replica_specifications[0].auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.disable_scale_in #=> Boolean
resp.replica_specifications[0].auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_in_cooldown #=> Integer
resp.replica_specifications[0].auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.scale_out_cooldown #=> Integer
resp.replica_specifications[0].auto_scaling_specification.read_capacity_auto_scaling.scaling_policy.target_tracking_scaling_policy_configuration.target_value #=> Float

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace.
    
          
        
    • 
      
        
  • 
          :table_name
          (required, String)
          
            
          
          
            — 
    The name of the table.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


273

    		
    
      
# File 'sig/client.rbs', line 273

def get_table_auto_scaling_settings: (

    		
  





    
      

  

  
    #get_type(params = {})  ⇒ Types::GetTypeResponse 
  

  

  




  

    
The GetType operation returns information about the type, for
example the field definitions, the timestamp when the type was last
modified, the level of nesting, the status, and details about if the
type is used in other types and tables.


To read keyspace metadata using GetType, the IAM principal needs
Select action permissions for the system keyspace. To configure the
required permissions, see Permissions to view a UDT in the
Amazon Keyspaces Developer Guide.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.get_type({
  keyspace_name: "KeyspaceName", # required
  type_name: "TypeName", # required
})

    
      
        
Response structure

      
      

resp.keyspace_name #=> String
resp.type_name #=> String
resp.field_definitions #=> Array
resp.field_definitions[0].name #=> String
resp.field_definitions[0].type #=> String
resp.last_modified_timestamp #=> Time
resp.status #=> String, one of "ACTIVE", "CREATING", "DELETING", "RESTORING"
resp.direct_referring_tables #=> Array
resp.direct_referring_tables[0] #=> String
resp.direct_parent_types #=> Array
resp.direct_parent_types[0] #=> String
resp.max_nesting_depth #=> Integer
resp.keyspace_arn #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace that contains this type.
    
          
        
    • 
      
        
  • 
          :type_name
          (required, String)
          
            
          
          
            — 
    The formatted name of the type. For example, if the name of the type
was created without double quotes, Amazon Keyspaces saved the name in
lower-case characters. If the name was created in double quotes, you
must use double quotes to specify the type name.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


292

    		
    
      
# File 'sig/client.rbs', line 292

def get_type: (

    		
  





    
      

  

  
    #list_keyspaces(params = {})  ⇒ Types::ListKeyspacesResponse 
  

  

  




  

    
The ListKeyspaces operation returns a list of keyspaces.


The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.list_keyspaces({
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.next_token #=> String
resp.keyspaces #=> Array
resp.keyspaces[0].keyspace_name #=> String
resp.keyspaces[0].resource_arn #=> String
resp.keyspaces[0].replication_strategy #=> String, one of "SINGLE_REGION", "MULTI_REGION"
resp.keyspaces[0].replication_regions #=> Array
resp.keyspaces[0].replication_regions[0] #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The pagination token. To resume pagination, provide the NextToken
value as argument of a subsequent API invocation.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The total number of keyspaces to return in the output. If the total
number of keyspaces available is more than the value specified, a
NextToken is provided in the output. To resume pagination, provide
the NextToken value as an argument of a subsequent API invocation.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


304

    		
    
      
# File 'sig/client.rbs', line 304

def list_keyspaces: (

    		
  





    
      

  

  
    #list_tables(params = {})  ⇒ Types::ListTablesResponse 
  

  

  




  

    
The ListTables operation returns a list of tables for a specified
keyspace.


To read keyspace metadata using ListTables, the IAM principal needs
Select action permissions for the system keyspace.


The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.list_tables({
  next_token: "NextToken",
  max_results: 1,
  keyspace_name: "KeyspaceName", # required
})

    
      
        
Response structure

      
      

resp.next_token #=> String
resp.tables #=> Array
resp.tables[0].keyspace_name #=> String
resp.tables[0].table_name #=> String
resp.tables[0].resource_arn #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The pagination token. To resume pagination, provide the NextToken
value as an argument of a subsequent API invocation.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The total number of tables to return in the output. If the total
number of tables available is more than the value specified, a
NextToken is provided in the output. To resume pagination, provide
the NextToken value as an argument of a subsequent API invocation.
    
          
        
    • 
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


316

    		
    
      
# File 'sig/client.rbs', line 316

def list_tables: (

    		
  





    
      

  

  
    #list_tags_for_resource(params = {})  ⇒ Types::ListTagsForResourceResponse 
  

  

  




  

    
Returns a list of all tags associated with the specified Amazon
Keyspaces resource.


To read keyspace metadata using ListTagsForResource, the IAM
principal needs Select action permissions for the specified resource
and the system keyspace.


The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.list_tags_for_resource({
  resource_arn: "ARN", # required
  next_token: "NextToken",
  max_results: 1,
})

    
      
        
Response structure

      
      

resp.next_token #=> String
resp.tags #=> Array
resp.tags[0].key #=> String
resp.tags[0].value #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :resource_arn
          (required, String)
          
            
          
          
            — 
    The Amazon Resource Name (ARN) of the Amazon Keyspaces resource.
    
          
        
    • 
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The pagination token. To resume pagination, provide the NextToken
value as argument of a subsequent API invocation.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The total number of tags to return in the output. If the total number
of tags available is more than the value specified, a NextToken is
provided in the output. To resume pagination, provide the NextToken
value as an argument of a subsequent API invocation.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


329

    		
    
      
# File 'sig/client.rbs', line 329

def list_tags_for_resource: (

    		
  





    
      

  

  
    #list_types(params = {})  ⇒ Types::ListTypesResponse 
  

  

  




  

    
The ListTypes operation returns a list of types for a specified
keyspace.


To read keyspace metadata using ListTypes, the IAM principal needs
Select action permissions for the system keyspace. To configure the
required permissions, see Permissions to view a UDT in the
Amazon Keyspaces Developer Guide.


The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.list_types({
  next_token: "NextToken",
  max_results: 1,
  keyspace_name: "KeyspaceName", # required
})

    
      
        
Response structure

      
      

resp.next_token #=> String
resp.types #=> Array
resp.types[0] #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :next_token
          (String)
          
            
          
          
            — 
    The pagination token. To resume pagination, provide the NextToken
value as an argument of a subsequent API invocation.
    
          
        
    • 
      
        
  • 
          :max_results
          (Integer)
          
            
          
          
            — 
    The total number of types to return in the output. If the total number
of types available is more than the value specified, a NextToken is
provided in the output. To resume pagination, provide the NextToken
value as an argument of a subsequent API invocation.
    
          
        
    • 
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace that contains the listed types.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


342

    		
    
      
# File 'sig/client.rbs', line 342

def list_types: (

    		
  





    
      

  

  
    #restore_table(params = {})  ⇒ Types::RestoreTableResponse 
  

  

  




  

    
Restores the table to the specified point in time within the
earliest_restorable_timestamp and the current time. For more
information about restore points, see  Time window for PITR
continuous backups in the Amazon Keyspaces Developer Guide.


Any number of users can execute up to 4 concurrent restores (any type
of restore) in a given account.


When you restore using point in time recovery, Amazon Keyspaces
restores your source table's schema and data to the state based on
the selected timestamp (day:hour:minute:second) to a new table. The
Time to Live (TTL) settings are also restored to the state based on
the selected timestamp.


In addition to the table's schema, data, and TTL settings,
RestoreTable restores the capacity mode, auto scaling settings,
encryption settings, and point-in-time recovery settings from the
source table. Unlike the table's schema data and TTL settings, which
are restored based on the selected timestamp, these settings are
always restored based on the table's settings as of the current time
or when the table was deleted.


You can also overwrite these settings during restore:


    

  • 

    Read/write capacity mode
    

    • 

  • 

    Provisioned throughput capacity units
    

    • 

  • 

    Auto scaling settings
    

    • 

  • 

    Point-in-time (PITR) settings
    

    • 

  • 

    Tags
    

    • 



For more information, see PITR restore settings in the Amazon
Keyspaces Developer Guide.


Note that the following settings are not restored, and you must
configure them manually for the new table:


    

  • 

    Identity and Access Management (IAM) policies
    

    • 

  • 

    Amazon CloudWatch metrics and alarms
    

    • 



  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.restore_table({
  source_keyspace_name: "KeyspaceName", # required
  source_table_name: "TableName", # required
  target_keyspace_name: "KeyspaceName", # required
  target_table_name: "TableName", # required
  restore_timestamp: Time.now,
  capacity_specification_override: {
    throughput_mode: "PAY_PER_REQUEST", # required, accepts PAY_PER_REQUEST, PROVISIONED
    read_capacity_units: 1,
    write_capacity_units: 1,
  },
  encryption_specification_override: {
    type: "CUSTOMER_MANAGED_KMS_KEY", # required, accepts CUSTOMER_MANAGED_KMS_KEY, AWS_OWNED_KMS_KEY
    kms_key_identifier: "kmsKeyARN",
  },
  point_in_time_recovery_override: {
    status: "ENABLED", # required, accepts ENABLED, DISABLED
  },
  tags_override: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
  auto_scaling_specification: {
    write_capacity_auto_scaling: {
      auto_scaling_disabled: false,
      minimum_units: 1,
      maximum_units: 1,
      scaling_policy: {
        target_tracking_scaling_policy_configuration: {
          disable_scale_in: false,
          scale_in_cooldown: 1,
          scale_out_cooldown: 1,
          target_value: 1.0, # required
        },
      },
    },
    read_capacity_auto_scaling: {
      auto_scaling_disabled: false,
      minimum_units: 1,
      maximum_units: 1,
      scaling_policy: {
        target_tracking_scaling_policy_configuration: {
          disable_scale_in: false,
          scale_in_cooldown: 1,
          scale_out_cooldown: 1,
          target_value: 1.0, # required
        },
      },
    },
  },
  replica_specifications: [
    {
      region: "region", # required
      read_capacity_units: 1,
      read_capacity_auto_scaling: {
        auto_scaling_disabled: false,
        minimum_units: 1,
        maximum_units: 1,
        scaling_policy: {
          target_tracking_scaling_policy_configuration: {
            disable_scale_in: false,
            scale_in_cooldown: 1,
            scale_out_cooldown: 1,
            target_value: 1.0, # required
          },
        },
      },
    },
  ],
})

    
      
        
Response structure

      
      

resp.restored_table_arn #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :source_keyspace_name
          (required, String)
          
            
          
          
            — 
    The keyspace name of the source table.
    
          
        
    • 
      
        
  • 
          :source_table_name
          (required, String)
          
            
          
          
            — 
    The name of the source table.
    
          
        
    • 
      
        
  • 
          :target_keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the target keyspace.
    
          
        
    • 
      
        
  • 
          :target_table_name
          (required, String)
          
            
          
          
            — 
    The name of the target table.
    
          
        
    • 
      
        
  • 
          :restore_timestamp
          (Time, DateTime, Date, Integer, String)
          
            
          
          
            — 
    The restore timestamp in ISO 8601 format.
    
          
        
    • 
      
        
  • 
          :capacity_specification_override
          (Types::CapacitySpecification)
          
            
          
          
            — 
    Specifies the read/write throughput capacity mode for the target
table. The options are:
    

      

    • 

      throughputMode:PAY_PER_REQUEST
      

      • 

    • 

      throughputMode:PROVISIONED - Provisioned capacity mode requires
readCapacityUnits and writeCapacityUnits as input.
      

      • 

    

    The default is throughput_mode:PAY_PER_REQUEST.
    

    For more information, see Read/write capacity modes in the
Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :encryption_specification_override
          (Types::EncryptionSpecification)
          
            
          
          
            — 
    Specifies the encryption settings for the target table. You can choose
one of the following KMS key (KMS key):
    

      

    • 

      type:AWS_OWNED_KMS_KEY - This key is owned by Amazon Keyspaces.
      

      • 

    • 

      type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your account
and is created, owned, and managed by you. This option requires the
kms_key_identifier of the KMS key in Amazon Resource Name (ARN)
format as input.
      

      • 

    

    The default is type:AWS_OWNED_KMS_KEY.
    

    For more information, see Encryption at rest in the Amazon
Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :point_in_time_recovery_override
          (Types::PointInTimeRecovery)
          
            
          
          
            — 
    Specifies the pointInTimeRecovery settings for the target table. The
options are:
    

      

    • 

      status=ENABLED
      

      • 

    • 

      status=DISABLED
      

      • 

    

    If it's not specified, the default is status=DISABLED.
    

    For more information, see Point-in-time recovery in the Amazon
Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :tags_override
          (Array<Types::Tag>)
          
            
          
          
            — 
    A list of key-value pair tags to be attached to the restored table.
    

    For more information, see Adding tags and labels to Amazon Keyspaces
resources in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :auto_scaling_specification
          (Types::AutoScalingSpecification)
          
            
          
          
            — 
    The optional auto scaling settings for the restored table in
provisioned capacity mode. Specifies if the service can manage
throughput capacity of a provisioned table automatically on your
behalf. Amazon Keyspaces auto scaling helps you provision throughput
capacity for variable workloads efficiently by increasing and
decreasing your table's read and write capacity automatically in
response to application traffic.
    

    For more information, see Managing throughput capacity automatically
with Amazon Keyspaces auto scaling in the Amazon Keyspaces
Developer Guide.
    
          
        
    • 
      
        
  • 
          :replica_specifications
          (Array<Types::ReplicaSpecification>)
          
            
          
          
            — 
    The optional Region specific settings of a multi-Regional table.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


354

    		
    
      
# File 'sig/client.rbs', line 354

def restore_table: (

    		
  





    
      

  

  
    #tag_resource(params = {})  ⇒ Struct 
  

  

  




  

    
Associates a set of tags with a Amazon Keyspaces resource. You can
then activate these user-defined tags so that they appear on the Cost
Management Console for cost allocation tracking. For more information,
see Adding tags and labels to Amazon Keyspaces resources in the
Amazon Keyspaces Developer Guide.


For IAM policy examples that show how to control access to Amazon
Keyspaces resources based on tags, see Amazon Keyspaces resource
access based on tags in the Amazon Keyspaces Developer Guide.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.tag_resource({
  resource_arn: "ARN", # required
  tags: [ # required
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :resource_arn
          (required, String)
          
            
          
          
            — 
    The Amazon Resource Name (ARN) of the Amazon Keyspaces resource to
which to add tags.
    
          
        
    • 
      
        
  • 
          :tags
          (required, Array<Types::Tag>)
          
            
          
          
            — 
    The tags to be assigned to the Amazon Keyspaces resource.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


389

    		
    
      
# File 'sig/client.rbs', line 389

def tag_resource: (

    		
  





    
      

  

  
    #untag_resource(params = {})  ⇒ Struct 
  

  

  




  

    
Removes the association of tags from a Amazon Keyspaces resource.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.untag_resource({
  resource_arn: "ARN", # required
  tags: [ # required
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :resource_arn
          (required, String)
          
            
          
          
            — 
    The Amazon Keyspaces resource that the tags will be removed from. This
value is an Amazon Resource Name (ARN).
    
          
        
    • 
      
        
  • 
          :tags
          (required, Array<Types::Tag>)
          
            
          
          
            — 
    A list of existing tags to be removed from the Amazon Keyspaces
resource.
    
          
        
    • 
      
    

  
    
    


Returns:


    
  
    
  • 
      
      
        (Struct)
      
      
      
        —
        
    Returns an empty response.
    
      
    
    • 
  



  
See Also:

  



  

    
      


404

    		
    
      
# File 'sig/client.rbs', line 404

def untag_resource: (

    		
  





    
      

  

  
    #update_keyspace(params = {})  ⇒ Types::UpdateKeyspaceResponse 
  

  

  




  

    
Adds a new Amazon Web Services Region to the keyspace. You can add a
new Region to a keyspace that is either a single or a multi-Region
keyspace. Amazon Keyspaces is going to replicate all tables in the
keyspace to the new Region. To successfully replicate all tables to
the new Region, they must use client-side timestamps for conflict
resolution. To enable client-side timestamps, specify
clientSideTimestamps.status = enabled when invoking the API. For
more information about client-side timestamps, see Client-side
timestamps in Amazon Keyspaces in the Amazon Keyspaces Developer
Guide.


To add a Region to a keyspace using the UpdateKeyspace API, the IAM
principal needs permissions for the following IAM actions:


    

  • 

    cassandra:Alter
    

    • 

  • 

    cassandra:AlterMultiRegionResource
    

    • 

  • 

    cassandra:Create
    

    • 

  • 

    cassandra:CreateMultiRegionResource
    

    • 

  • 

    cassandra:Select
    

    • 

  • 

    cassandra:SelectMultiRegionResource
    

    • 

  • 

    cassandra:Modify
    

    • 

  • 

    cassandra:ModifyMultiRegionResource
    

    • 



If the keyspace contains a table that is configured in provisioned
mode with auto scaling enabled, the following additional IAM actions
need to be allowed.


    

  • 

    application-autoscaling:RegisterScalableTarget
    

    • 

  • 

    application-autoscaling:DeregisterScalableTarget
    

    • 

  • 

    application-autoscaling:DescribeScalableTargets
    

    • 

  • 

    application-autoscaling:PutScalingPolicy
    

    • 

  • 

    application-autoscaling:DescribeScalingPolicies
    

    • 



To use the UpdateKeyspace API, the IAM principal also needs
permissions to create a service-linked role with the following
elements:


    

  • 

    iam:CreateServiceLinkedRole - The action the principal can
perform.
    

    • 

  • 

    arn:aws:iam::*:role/aws-service-role/replication.cassandra.amazonaws.com/AWSServiceRoleForKeyspacesReplication
    

      

    • The resource that the action can be performed on.
      • 

    

    • 

  • 

    iam:AWSServiceName: replication.cassandra.amazonaws.com - The only
Amazon Web Services service that this role can be attached to is
Amazon Keyspaces.
    

    • 



For more information, see Configure the IAM permissions required to
add an Amazon Web Services Region to a keyspace in the Amazon
Keyspaces Developer Guide.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_keyspace({
  keyspace_name: "KeyspaceName", # required
  replication_specification: { # required
    replication_strategy: "SINGLE_REGION", # required, accepts SINGLE_REGION, MULTI_REGION
    region_list: ["region"],
  },
  client_side_timestamps: {
    status: "ENABLED", # required, accepts ENABLED
  },
})

    
      
        
Response structure

      
      

resp.resource_arn #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace.
    
          
        
    • 
      
        
  • 
          :replication_specification
          (required, Types::ReplicationSpecification)
          
            
          
          
            — 
    The replication specification of the keyspace includes:
    

      

    • 

      regionList - the Amazon Web Services Regions where the keyspace is
replicated in.
      

      • 

    • 

      replicationStrategy - the required value is SINGLE_REGION or
MULTI_REGION.
      

      • 

    
          
        
    • 
      
        
  • 
          :client_side_timestamps
          (Types::ClientSideTimestamps)
          
            
          
          
            — 
    The client-side timestamp setting of the table.
    

    For more information, see How it works: Amazon Keyspaces client-side
timestamps in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


420

    		
    
      
# File 'sig/client.rbs', line 420

def update_keyspace: (

    		
  





    
      

  

  
    #update_table(params = {})  ⇒ Types::UpdateTableResponse 
  

  

  




  

    
Adds new columns to the table or updates one of the table's settings,
for example capacity mode, auto scaling, encryption, point-in-time
recovery, or ttl settings. Note that you can only update one specific
table setting per update operation.


  





  
  

    
Examples:

    
      
        
Request syntax with placeholder values

      
      

resp = client.update_table({
  keyspace_name: "KeyspaceName", # required
  table_name: "TableName", # required
  add_columns: [
    {
      name: "GenericString", # required
      type: "GenericString", # required
    },
  ],
  capacity_specification: {
    throughput_mode: "PAY_PER_REQUEST", # required, accepts PAY_PER_REQUEST, PROVISIONED
    read_capacity_units: 1,
    write_capacity_units: 1,
  },
  encryption_specification: {
    type: "CUSTOMER_MANAGED_KMS_KEY", # required, accepts CUSTOMER_MANAGED_KMS_KEY, AWS_OWNED_KMS_KEY
    kms_key_identifier: "kmsKeyARN",
  },
  point_in_time_recovery: {
    status: "ENABLED", # required, accepts ENABLED, DISABLED
  },
  ttl: {
    status: "ENABLED", # required, accepts ENABLED
  },
  default_time_to_live: 1,
  client_side_timestamps: {
    status: "ENABLED", # required, accepts ENABLED
  },
  auto_scaling_specification: {
    write_capacity_auto_scaling: {
      auto_scaling_disabled: false,
      minimum_units: 1,
      maximum_units: 1,
      scaling_policy: {
        target_tracking_scaling_policy_configuration: {
          disable_scale_in: false,
          scale_in_cooldown: 1,
          scale_out_cooldown: 1,
          target_value: 1.0, # required
        },
      },
    },
    read_capacity_auto_scaling: {
      auto_scaling_disabled: false,
      minimum_units: 1,
      maximum_units: 1,
      scaling_policy: {
        target_tracking_scaling_policy_configuration: {
          disable_scale_in: false,
          scale_in_cooldown: 1,
          scale_out_cooldown: 1,
          target_value: 1.0, # required
        },
      },
    },
  },
  replica_specifications: [
    {
      region: "region", # required
      read_capacity_units: 1,
      read_capacity_auto_scaling: {
        auto_scaling_disabled: false,
        minimum_units: 1,
        maximum_units: 1,
        scaling_policy: {
          target_tracking_scaling_policy_configuration: {
            disable_scale_in: false,
            scale_in_cooldown: 1,
            scale_out_cooldown: 1,
            target_value: 1.0, # required
          },
        },
      },
    },
  ],
  cdc_specification: {
    status: "ENABLED", # required, accepts ENABLED, ENABLING, DISABLED, DISABLING
    view_type: "NEW_IMAGE", # accepts NEW_IMAGE, OLD_IMAGE, KEYS_ONLY, NEW_AND_OLD_IMAGES
    tags: [
      {
        key: "TagKey", # required
        value: "TagValue", # required
      },
    ],
    propagate_tags: "TABLE", # accepts TABLE, NONE
  },
  warm_throughput_specification: {
    read_units_per_second: 1,
    write_units_per_second: 1,
  },
})

    
      
        
Response structure

      
      

resp.resource_arn #=> String

    
  


  

Parameters:


    
  
    
  • 
      
        params
      
      
        (Hash)
      
      
        (defaults to: {})
      
      
        —
        
    ({})
    
      
    
    • 
  



  
    
    
    
Options Hash (params):

    
    
      
        
  • 
          :keyspace_name
          (required, String)
          
            
          
          
            — 
    The name of the keyspace the specified table is stored in.
    
          
        
    • 
      
        
  • 
          :table_name
          (required, String)
          
            
          
          
            — 
    The name of the table.
    
          
        
    • 
      
        
  • 
          :add_columns
          (Array<Types::ColumnDefinition>)
          
            
          
          
            — 
    For each column to be added to the specified table:
    

      

    • 

      name - The name of the column.
      

      • 

    • 

      type - An Amazon Keyspaces data type. For more information, see
Data types in the Amazon Keyspaces Developer Guide.
      

      • 

    
          
        
    • 
      
        
  • 
          :capacity_specification
          (Types::CapacitySpecification)
          
            
          
          
            — 
    Modifies the read/write throughput capacity mode for the table. The
options are:
    

      

    • 

      throughputMode:PAY_PER_REQUEST and
      

      • 

    • 

      throughputMode:PROVISIONED - Provisioned capacity mode requires
readCapacityUnits and writeCapacityUnits as input.
      

      • 

    

    The default is throughput_mode:PAY_PER_REQUEST.
    

    For more information, see Read/write capacity modes in the
Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :encryption_specification
          (Types::EncryptionSpecification)
          
            
          
          
            — 
    Modifies the encryption settings of the table. You can choose one of
the following KMS key (KMS key):
    

      

    • 

      type:AWS_OWNED_KMS_KEY - This key is owned by Amazon Keyspaces.
      

      • 

    • 

      type:CUSTOMER_MANAGED_KMS_KEY - This key is stored in your account
and is created, owned, and managed by you. This option requires the
kms_key_identifier of the KMS key in Amazon Resource Name (ARN)
format as input.
      

      • 

    

    The default is AWS_OWNED_KMS_KEY.
    

    For more information, see Encryption at rest in the Amazon
Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :point_in_time_recovery
          (Types::PointInTimeRecovery)
          
            
          
          
            — 
    Modifies the pointInTimeRecovery settings of the table. The options
are:
    

      

    • 

      status=ENABLED
      

      • 

    • 

      status=DISABLED
      

      • 

    

    If it's not specified, the default is status=DISABLED.
    

    For more information, see Point-in-time recovery in the Amazon
Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :ttl
          (Types::TimeToLive)
          
            
          
          
            — 
    Modifies Time to Live custom settings for the table. The options are:
    

      

    • 

      status:enabled
      

      • 

    • 

      status:disabled
      

      • 

    

    The default is status:disabled. After ttl is enabled, you can't
disable it for the table.
    

    For more information, see Expiring data by using Amazon Keyspaces
Time to Live (TTL) in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :default_time_to_live
          (Integer)
          
            
          
          
            — 
    The default Time to Live setting in seconds for the table.
    

    For more information, see Setting the default TTL value for a
table in the Amazon Keyspaces Developer Guide.
    
          
        
    • 
      
        
  • 
          :client_side_timestamps
          (Types::ClientSideTimestamps)
          
            
          
          
            — 
    Enables client-side timestamps for the table. By default, the setting
is disabled. You can enable client-side timestamps with the following
option:
    

      

    • status: "enabled"
      • 

    

    ^
    

    Once client-side timestamps are enabled for a table, this setting
cannot be disabled.
    
          
        
    • 
      
        
  • 
          :auto_scaling_specification
          (Types::AutoScalingSpecification)
          
            
          
          
            — 
    The optional auto scaling settings to update for a table in
provisioned capacity mode. Specifies if the service can manage
throughput capacity of a provisioned table automatically on your
behalf. Amazon Keyspaces auto scaling helps you provision throughput
capacity for variable workloads efficiently by increasing and
decreasing your table's read and write capacity automatically in
response to application traffic.
    

    If auto scaling is already enabled for the table, you can use
UpdateTable to update the minimum and maximum values or the auto
scaling policy settings independently.
    

    For more information, see Managing throughput capacity automatically
with Amazon Keyspaces auto scaling in the Amazon Keyspaces
Developer Guide.
    
          
        
    • 
      
        
  • 
          :replica_specifications
          (Array<Types::ReplicaSpecification>)
          
            
          
          
            — 
    The Region specific settings of a multi-Regional table.
    
          
        
    • 
      
        
  • 
          :cdc_specification
          (Types::CdcSpecification)
          
            
          
          
            — 
    The CDC stream settings of the table.
    
          
        
    • 
      
        
  • 
          :warm_throughput_specification
          (Types::WarmThroughputSpecification)
          
            
          
          
            — 
    Modifies the warm throughput settings for the table. You can update
the read and write capacity units to adjust the pre-provisioned
throughput.
    
          
        
    • 
      
    

  
    
    


Returns:



  
See Also:

  



  

    
      


437

    		
    
      
# File 'sig/client.rbs', line 437

def update_table: (

    		
  





    
      

  

  
    #waiter_names  ⇒ Object 
  

  

  




  

    

  This method is part of a private API.
  You should avoid using this method if possible, as it may be removed or be changed in the future.



Deprecated. 



  





  



  

    
      


2305
2306
2307

    		
    
      
# File 'lib/aws-sdk-keyspaces/client.rb', line 2305

def waiter_names
  []
end