messagemedia_signingkeys_sdk 1.0.0

data/lib/message_media_signing_keys/api_helper.rb

@@ -0,0 +1,273 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaSigningKeys
+  # API utility class
+  class APIHelper
+    # Serializes an array parameter (creates key value pairs).
+    # @param [String] The name of the parameter.
+    # @param [Array] The value of the parameter.
+    # @param [String] The format of the serialization.
+    def self.serialize_array(key, array, formatting: 'indexed')
+      tuples = []
+
+      if formatting == 'unindexed'
+        tuples += array.map { |element| ["#{key}[]", element] }
+      elsif formatting == 'indexed'
+        tuples += array.map.with_index do |element, index|
+          ["#{key}[#{index}]", element]
+        end
+      elsif formatting == 'plain'
+        tuples += array.map { |element| [key, element] }
+      else
+        raise ArgumentError, 'Invalid format provided.'
+      end
+      tuples
+    end
+
+    # Replaces template parameters in the given url.
+    # @param [String] The query string builder to replace the template
+    # parameters.
+    # @param [Hash] The parameters to replace in the url.
+    def self.append_url_with_template_parameters(query_builder, parameters)
+      # perform parameter validation
+      unless query_builder.instance_of? String
+        raise ArgumentError, 'Given value for parameter \"query_builder\" is
+          invalid.'
+      end
+
+      # Return if there are no parameters to replace.
+      return query_builder if parameters.nil?
+
+      # Iterate and append parameters.
+      parameters.each do |key, value|
+        replace_value = ''
+
+        if value.nil?
+          replace_value = ''
+        elsif value.instance_of? Array
+          value.map! { |element| CGI.escape(element.to_s) }
+          replace_value = value.join('/')
+        else
+          replace_value = CGI.escape(value.to_s)
+        end
+
+        # Find the template parameter and replace it with its value.
+        query_builder = query_builder.gsub('{' + key.to_s + '}', replace_value)
+      end
+      query_builder
+    end
+
+    # Appends the given set of parameters to the given query string.
+    # @param [String] The query string builder to add the query parameters to.
+    # @param [Hash] The parameters to append.
+    # @param [String] The format of array parameter serialization.
+    def self.append_url_with_query_parameters(query_builder, parameters,
+                                              array_serialization: 'indexed')
+      # Perform parameter validation.
+      unless query_builder.instance_of? String
+        raise ArgumentError, 'Given value for parameter \"query_builder\"
+          is invalid.'
+      end
+
+      # Return if there are no parameters to replace.
+      return query_builder if parameters.nil?
+
+      parameters.each do |key, value|
+        seperator = query_builder.include?('?') ? '&' : '?'
+        unless value.nil?
+          if value.instance_of? Array
+            value.compact!
+            query_builder += if array_serialization == 'csv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join(',')}"
+                             elsif array_serialization == 'psv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join('|')}"
+                             elsif array_serialization == 'tsv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join("\t")}"
+                             else
+                               "#{seperator}#{APIHelper.serialize_array(
+                                 key, value, formatting: array_serialization
+                               ).map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }
+                               .join('&')}"
+                             end
+          else
+            query_builder += "#{seperator}#{key}=#{CGI.escape(value.to_s)}"
+          end
+        end
+      end
+      query_builder
+    end
+
+    # Validates and processes the given Url.
+    # @param [String] The given Url to process.
+    # @return [String] Pre-processed Url as string.
+    def self.clean_url(url)
+      # Perform parameter validation.
+      raise ArgumentError, 'Invalid Url.' unless url.instance_of? String
+
+      # Ensure that the urls are absolute.
+      matches = url.match(%r{^(https?:\/\/[^\/]+)})
+      raise ArgumentError, 'Invalid Url format.' if matches.nil?
+
+      # Get the http protocol match.
+      protocol = matches[1]
+
+      # Check if parameters exist.
+      index = url.index('?')
+
+      # Remove redundant forward slashes.
+      query = url[protocol.length...(!index.nil? ? index : url.length)]
+      query.gsub!(%r{\/\/+}, '/')
+
+      # Get the parameters.
+      parameters = !index.nil? ? url[url.index('?')...url.length] : ''
+
+      # Return processed url.
+      protocol + query + parameters
+    end
+
+    # Parses JSON string.
+    # @param [String] A JSON string.
+    def self.json_deserialize(json)
+      return JSON.parse(json)
+    rescue StandardError
+      raise TypeError, 'Server responded with invalid JSON.'
+    end
+
+    # Removes elements with empty values from a hash.
+    # @param [Hash] The hash to clean.
+    def self.clean_hash(hash)
+      hash.delete_if { |_key, value| value.to_s.strip.empty? }
+    end
+
+    # Form encodes a hash of parameters.
+    # @param [Hash] The hash of parameters to encode.
+    # @return [Hash] A hash with the same parameters form encoded.
+    def self.form_encode_parameters(form_parameters)
+      encoded = {}
+      form_parameters.each do |key, value|
+        encoded.merge!(APIHelper.form_encode(value, key, formatting:
+          Configuration.array_serialization))
+      end
+      encoded
+    end
+
+    def self.custom_merge(a, b)
+      x = {}
+      a.each do |key, value_a|
+        b.each do |k, value_b|
+          next unless key == k
+          x[k] = []
+          if value_a.instance_of? Array
+            value_a.each do |v|
+              x[k].push(v)
+            end
+          else
+            x[k].push(value_a)
+          end
+          if value_b.instance_of? Array
+            value_b.each do |v|
+              x[k].push(v)
+            end
+          else
+            x[k].push(value_b)
+          end
+          a.delete(k)
+          b.delete(k)
+        end
+      end
+      x.merge!(a)
+      x.merge!(b)
+      x
+    end
+
+    # Form encodes an object.
+    # @param [Dynamic] An object to form encode.
+    # @param [String] The name of the object.
+    # @return [Hash] A form encoded representation of the object in the form
+    # of a hash.
+    def self.form_encode(obj, instance_name, formatting: 'indexed')
+      retval = {}
+
+      serializable_types = [String, Numeric, TrueClass,
+                            FalseClass, Date, DateTime]
+
+      # If this is a structure, resolve it's field names.
+      obj = obj.to_hash if obj.is_a? BaseModel
+
+      # Create a form encoded hash for this object.
+      if obj.nil?
+        nil
+      elsif obj.instance_of? Array
+        if formatting == 'indexed'
+          obj.each_with_index do |value, index|
+            retval.merge!(APIHelper.form_encode(value, instance_name + '[' +
+              index.to_s + ']'))
+          end
+        elsif serializable_types.map { |x| obj[0].is_a? x }.any?
+          obj.each do |value|
+            abc = if formatting == 'unindexed'
+                    APIHelper.form_encode(value, instance_name + '[]',
+                                          formatting: formatting)
+                  else
+                    APIHelper.form_encode(value, instance_name,
+                                          formatting: formatting)
+                  end
+            retval = APIHelper.custom_merge(retval, abc)
+            # print retval
+          end
+        else
+          obj.each_with_index do |value, index|
+            retval.merge!(APIHelper.form_encode(value, instance_name + '[' +
+              index.to_s + ']', formatting: formatting))
+          end
+        end
+      elsif obj.instance_of? Hash
+        obj.each do |key, value|
+          retval.merge!(APIHelper.form_encode(value, instance_name + '[' +
+            key + ']', formatting: formatting))
+        end
+      else
+        retval[instance_name] = obj
+      end
+      retval
+    end
+
+    # Safely converts a string into an rfc3339 DateTime object
+    # @param [String] The datetime string
+    # @return [DateTime] A DateTime object of rfc3339 format
+    def self.rfc3339(date_time)
+      # missing timezone information
+      if date_time.end_with?('Z') || date_time.index('+')
+        DateTime.rfc3339(date_time)
+      else
+        DateTime.rfc3339(date_time + 'Z')
+      end
+    end
+  end
+end
+
+# Extend types to support to_bool.
+module ToBoolean
+  def to_bool
+    return true if self == true || to_s.strip =~ /^(true|yes|y|1)$/i
+    false
+  end
+end
+
+# Extend NilClass type to support to_bool.
+class NilClass; include ToBoolean; end
+# Extend TrueClass type to support to_bool.
+class TrueClass; include ToBoolean; end
+# Extend FalseClass type to support to_bool.
+class FalseClass; include ToBoolean; end
+# Extend Numeric type to support to_bool.
+class Numeric; include ToBoolean; end
+# Extend String type to support to_bool.
+class String; include ToBoolean; end

data/lib/message_media_signing_keys/configuration.rb

@@ -0,0 +1,29 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaSigningKeys
+
+  Logging.logger.root.appenders = Logging.appenders.stdout
+  Logging.logger.root.level = :info
+
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration
+    # The base Uri for API calls
+    @base_uri = 'https://api.messagemedia.com'
+
+    # The username to use with basic authentication
+    @basic_auth_user_name = 'TODO: Replace'
+
+    # The password to use with basic authentication
+    @basic_auth_password = 'TODO: Replace'
+
+    # The attribute accessors for public properties.
+    class << self
+      attr_accessor :array_serialization
+      attr_accessor :base_uri
+      attr_accessor :basic_auth_user_name
+      attr_accessor :basic_auth_password
+    end
+  end
+end

data/lib/message_media_signing_keys/controllers/base_controller.rb

@@ -0,0 +1,59 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaSigningKeys
+  # Base controller.
+  class BaseController
+    attr_accessor :http_client, :http_call_back
+
+    def initialize(http_client: nil, http_call_back: nil)
+      @http_client = http_client || FaradayClient.new
+      @http_call_back = http_call_back
+
+      @global_headers = {
+        'user-agent' => 'messagemedia-signingkeys-sdk-1.0.0'
+      }
+      @logger = Logging.logger[self]
+      @logger.info("Instantiated controller class.")
+    end
+
+    def validate_parameters(args)
+      args.each do |_name, value|
+        if value.nil?
+          raise ArgumentError, "Required parameter #{_name} cannot be nil."
+        end
+      end
+    end
+
+    def execute_request(request, binary: false, name: nil)
+      @logger.info("Calling the on_before_request method of http_call_back for #{name}.") if @http_call_back
+      @http_call_back.on_before_request(request) if @http_call_back
+
+      @logger.info("Merging global headers with endpoint headers for #{name}.")
+      APIHelper.clean_hash(request.headers)
+      request.headers = @global_headers.clone.merge(request.headers)
+
+      @logger.debug("Raw request for #{name} is: #{request.inspect}")
+      response = if binary
+                   @http_client.execute_as_binary(request)
+                 else
+                   @http_client.execute_as_string(request)
+                 end
+      @logger.debug("Raw response for #{name} is: #{response.inspect}")
+      @logger.info("Wrapping request and response in a context object for #{name}.")
+      context = HttpContext.new(request, response)
+
+      @logger.info("Calling on_after_response method of http_call_back for #{name}.") if @http_call_back
+      @http_call_back.on_after_response(context) if @http_call_back
+
+      context
+    end
+
+    def validate_response(context)
+      raise CreateSignatureKey403ResponseException.new 'Unexpected error in API call. See HTTP response body for details.', context if
+      context.response.status_code == 403
+      raise APIException.new 'HTTP Response Not OK', context unless
+        context.response.status_code.between?(200, 208) # [200,208] = HTTP OK
+    end
+  end
+end

data/lib/message_media_signing_keys/controllers/signature_key_management_controller.rb

@@ -0,0 +1,507 @@
+# This file was automatically generated for MessageMedia by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module MessageMediaSigningKeys
+  # SignatureKeyManagementController
+  class SignatureKeyManagementController < BaseController
+    @instance = SignatureKeyManagementController.new
+
+    class << self
+      attr_accessor :instance
+    end
+
+    def instance
+      self.class.instance
+    end
+
+    # Disable the current enabled signature key.
+    # A successful request for the ```disable the current enabled signature
+    # key.``` endpoint will return no content when successful.
+    # If there is an enabled key, it will be disabled; and the 204 status code
+    # is returned.
+    # If there is no key or no enabled key, the 204 status code is also
+    # returned.
+    # @param [String] content_type Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @return void response from the API call
+    def delete_disable_the_current_enabled_signature_key(content_type,
+                                                         accept)
+      begin
+        @logger.info("delete_disable_the_current_enabled_signature_key called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for delete_disable_the_current_enabled_signature_key.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/iam/signature_keys/enabled'
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for delete_disable_the_current_enabled_signature_key.")
+        _headers = {
+          'Content-Type' => content_type,
+          'Accept' => accept
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for delete_disable_the_current_enabled_signature_key.')
+        _request = @http_client.delete(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'delete_disable_the_current_enabled_signature_key')
+        validate_response(_context)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Delete a signature key using the key_id returned in the ```create
+    # signature key``` endpoint.
+    # A successful request for the ```delete signature key``` endpoint will
+    # return an empty response body.
+    # *Note: If an invalid or non-existent key_id parameter is specified in the
+    # request, then an HTTP 404 Not Found response will be returned*
+    # @param [String] key_id Required parameter: Example:
+    # @param [String] content_type Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @return void response from the API call
+    def delete_signature_key(key_id,
+                             content_type,
+                             accept)
+      begin
+        @logger.info("delete_signature_key called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for delete_signature_key.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/iam/signature_keys/{key_id}'
+        _query_builder = APIHelper.append_url_with_template_parameters(
+          _query_builder,
+          'key_id' => key_id
+        )
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for delete_signature_key.")
+        _headers = {
+          'Content-Type' => content_type,
+          'Accept' => accept
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for delete_signature_key.')
+        _request = @http_client.delete(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'delete_signature_key')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for delete_signature_key.")
+        if _context.response.status_code == 404
+          raise DeleteSignatureKey403ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        end
+        validate_response(_context)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Retrieve the current detail of a signature key using the key_id returned
+    # in the ```create signature key``` endpoint.
+    # A successful request for the ```get signature key detail``` endpoint will
+    # return a response body as follows:
+    # ```json
+    # {
+    #     "key_id": "7ca628a8-08b0-4e42-aeb8-960b37049c31",
+    #     "cipher": "RSA",
+    #     "digest": "SHA224",
+    #     "created": "2018-01-18T10:16:12.364Z",
+    #     "enabled": false
+    # }
+    # ```
+    # *Note: If an invalid or non-existent key_id parameter is specified in the
+    # request, then an HTTP 404 Not Found response will be returned*
+    # @param [String] key_id Required parameter: Example:
+    # @param [String] content_type Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @return GETSignatureKeyDetailResponse response from the API call
+    def get_signature_key_detail(key_id,
+                                 content_type,
+                                 accept)
+      begin
+        @logger.info("get_signature_key_detail called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for get_signature_key_detail.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/iam/signature_keys/{key_id}'
+        _query_builder = APIHelper.append_url_with_template_parameters(
+          _query_builder,
+          'key_id' => key_id
+        )
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for get_signature_key_detail.")
+        _headers = {
+          'Content-Type' => content_type,
+          'Accept' => accept
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for get_signature_key_detail.')
+        _request = @http_client.get(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'get_signature_key_detail')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for get_signature_key_detail.")
+        if _context.response.status_code == 400
+          raise GETSignatureKeyDetail400ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        elsif _context.response.status_code == 404
+          raise GETSignatureKeyDetail403ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for get_signature_key_detail.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        GETSignatureKeyDetailResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # This will create a key pair:
+    # - The ```private key``` stored in MessageMedia is used to create the
+    # signature.
+    # - The ```public key``` is returned and stored at your side to verify the
+    # signature in callbacks.
+    # You need to enable your signature key after creating.
+    # The most basic body has the following structure:
+    # ```json
+    # {
+    #     "digest": "SHA224",
+    #     "cipher": "RSA"
+    # }
+    # ```
+    # - ```digest``` is used to hash the message. The valid values for digest
+    # type are: SHA224, SHA256, SHA512
+    # - ```cipher``` is used to encrypt the hashed message. The valid value for
+    # cipher type is: RSA
+    # A successful request for the ```create signature key``` endpoint will
+    # return a response body as follows:
+    # ```json
+    # {
+    #     "key_id": "7ca628a8-08b0-4e42-aeb8-960b37049c31",
+    #     "public_key":
+    # "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCTIxtRyT5CuOD74r7UCT+AKzWNxvaAP9myj
+    # AqR7+vBnJKEvoPnmbKTnm6uLlxutnMbjKrnCCWnQ9vtBVnnd+ElhwLDPADfMcJoOqwi7mTcxuc
+    # ckeEbBsfsgYRfdacxgSZL8hVD1hLViQr3xwjEIkJcx1w3x8npvwMuTY0uW8+PjwIDAQAB",
+    #     "cipher": "RSA",
+    #     "digest": "SHA224",
+    #     "created": "2018-01-18T10:16:12.364Z",
+    #     "enabled": false
+    # }
+    # ```
+    # The response body of a successful POST request to the ```create signature
+    # key``` endpoint will contain six properties:
+    # - ```key_id``` will be a 36 character UUID which can be used to enable,
+    # delete or get the details.
+    # - ```public_key``` is used to decrypt the signature.
+    # - ```cipher``` same as cipher in request body.
+    # - ```digest``` same as digest in request body.
+    # - ```created``` is the created date.
+    # - ```enabled``` is false for the new signature key. You can use the
+    # ```enable signature key``` endpoint to set this field to true.
+    # @param [String] content_type Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @param [CreateSignatureKeyRequest] body Required parameter: Example:
+    # @return CreateSignatureKeyResponse response from the API call
+    def create_signature_key(content_type,
+                             accept,
+                             body)
+      begin
+        @logger.info("create_signature_key called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for create_signature_key.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/iam/signature_keys'
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for create_signature_key.")
+        _headers = {
+          'Content-Type' => content_type,
+          'Accept' => accept
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for create_signature_key.')
+        _request = @http_client.post(
+          _query_url,
+          headers: _headers,
+          parameters: body.to_json
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'create_signature_key')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for create_signature_key.")
+        if _context.response.status_code == 400
+          raise CreateSignatureKey400ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for create_signature_key.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        CreateSignatureKeyResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Retrieve the currently enabled signature key.
+    # A successful request for the ```get enabled signature key``` endpoint will
+    # return a response body as follows:
+    # ```json
+    # {
+    #     "key_id": "7ca628a8-08b0-4e42-aeb8-960b37049c31",
+    #     "cipher": "RSA",
+    #     "digest": "SHA224",
+    #     "created": "2018-01-18T10:16:12.364Z",
+    #     "enabled": true
+    # }
+    # ```
+    # *Note: If there is no enabled signature key, then an HTTP 404 Not Found
+    # response will be returned*
+    # @param [String] content_type Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @return GetEnabledSignatureKeyResponse response from the API call
+    def get_enabled_signature_key(content_type,
+                                  accept)
+      begin
+        @logger.info("get_enabled_signature_key called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for get_enabled_signature_key.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/iam/signature_keys/enabled'
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for get_enabled_signature_key.")
+        _headers = {
+          'Content-Type' => content_type,
+          'Accept' => accept
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for get_enabled_signature_key.')
+        _request = @http_client.get(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'get_enabled_signature_key')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for get_enabled_signature_key.")
+        if _context.response.status_code == 404
+          raise GetEnabledSignatureKey403ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for get_enabled_signature_key.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        GetEnabledSignatureKeyResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Enable a signature key using the key_id returned in the ```create
+    # signature key``` endpoint.
+    # There is only one signature key is enabled at the one moment in time. So
+    # if you enable the new signature key, the old one will be disabled.
+    # The most basic body has the following structure:
+    # ```json
+    # {
+    #     "key_id": "7ca628a8-08b0-4e42-aeb8-960b37049c31"
+    # }
+    # ```
+    # The response body of a successful PATCH request to ```enable signature
+    # key``` endpoint will contain the ```enabled``` properties with the value
+    # is true as follows:
+    # ```json
+    # {
+    #     "key_id": "7ca628a8-08b0-4e42-aeb8-960b37049c31",
+    #     "cipher": "RSA",
+    #     "digest": "SHA224",
+    #     "created": "2018-01-18T10:16:12.364Z",
+    #     "enabled": true
+    # }
+    # ```
+    # *Note: If an invalid or non-existent key_id parameter is specified in the
+    # request, then an HTTP 404 Not Found response will be returned*
+    # @param [String] content_type Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @param [EnableSignatureKeyRequest] body Required parameter: Example:
+    # @return EnableSignatureKeyResponse response from the API call
+    def update_enable_signature_key(content_type,
+                                    accept,
+                                    body)
+      begin
+        @logger.info("update_enable_signature_key called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for update_enable_signature_key.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/iam/signature_keys/enabled'
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for update_enable_signature_key.")
+        _headers = {
+          'Content-Type' => content_type,
+          'Accept' => accept
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for update_enable_signature_key.')
+        _request = @http_client.patch(
+          _query_url,
+          headers: _headers,
+          parameters: body.to_json
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'update_enable_signature_key')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for update_enable_signature_key.")
+        if _context.response.status_code == 400
+          raise EnableSignatureKey400ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        elsif _context.response.status_code == 404
+          raise EnableSignatureKey403ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for update_enable_signature_key.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        EnableSignatureKeyResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+
+    # Retrieve the paginated list of signature keys.
+    # A successful request for the ```get signature key list``` endpoint will
+    # return a response body as follows:
+    # ```json
+    # [
+    #   {
+    #     "key_id": "7ca628a8-08b0-4e42-aeb8-960b37049c31",
+    #     "cipher": "RSA",
+    #     "digest": "SHA224",
+    #     "created": "2018-01-18T10:16:12.364Z",
+    #     "enabled": false
+    #   }
+    # ]
+    # ```
+    # @param [String] content_type Required parameter: Example:
+    # @param [String] accept Required parameter: Example:
+    # @param [String] page Optional parameter: Example:
+    # @param [String] page_size Optional parameter: Example:
+    # @return List of GETSignatureKeyListResponse response from the API call
+    def get_signature_key_list(content_type,
+                               accept,
+                               page = nil,
+                               page_size = nil)
+      begin
+        @logger.info("get_signature_key_list called.")
+        # Prepare query url.
+        @logger.info("Preparing query URL for get_signature_key_list.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/iam/signature_keys?page={page}&page_size={page_size}'
+        _query_builder = APIHelper.append_url_with_template_parameters(
+          _query_builder,
+          'page' => page,
+          'page_size' => page_size
+        )
+        _query_url = APIHelper.clean_url _query_builder
+  
+        # Prepare headers.
+        @logger.info("Preparing headers for get_signature_key_list.")
+        _headers = {
+          'Content-Type' => content_type,
+          'Accept' => accept
+        }
+  
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for get_signature_key_list.')
+        _request = @http_client.get(
+          _query_url,
+          headers: _headers
+        )
+        BasicAuth.apply(_request)
+        _context = execute_request(_request, name: 'get_signature_key_list')
+  
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for get_signature_key_list.")
+        if _context.response.status_code == 400
+          raise GETSignatureKeyList400ResponseException.new(
+            'Unexpected error in API call. See HTTP response body for details.',
+            _context
+          )
+        end
+        validate_response(_context)
+  
+        # Return appropriate response type.
+        @logger.info("Returning response for get_signature_key_list.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        decoded.map { |element| GETSignatureKeyListResponse.from_hash(element) }
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+  end
+end