mailslurp_client 16.2.4 → 17.0.0

data/lib/mailslurp_client/api/{inbox_ruleset_controller_api.rb → ruleset_controller_api.rb}

@@ -13,36 +13,38 @@ OpenAPI Generator version: 4.3.1
 require 'cgi'
 
 module MailSlurpClient
-  class InboxRulesetControllerApi
+  class RulesetControllerApi
     attr_accessor :api_client
 
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     end
-    # Create an inbox ruleset
-    # Create a new inbox rule for forwarding, blocking, and allowing emails when sending and receiving
-    # @param create_inbox_ruleset_options [CreateInboxRulesetOptions] 
+    # Create a ruleset
+    # Create a new inbox or phone number rule for forwarding, blocking, and allowing emails or SMS when sending and receiving
+    # @param create_ruleset_options [CreateRulesetOptions] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :inbox_id Inbox id to attach ruleset to
-    # @return [InboxRulesetDto]
-    def create_new_inbox_ruleset(create_inbox_ruleset_options, opts = {})
-      data, _status_code, _headers = create_new_inbox_ruleset_with_http_info(create_inbox_ruleset_options, opts)
+    # @option opts [String] :phone_id Phone id to attach ruleset to
+    # @return [RulesetDto]
+    def create_new_ruleset(create_ruleset_options, opts = {})
+      data, _status_code, _headers = create_new_ruleset_with_http_info(create_ruleset_options, opts)
       data
     end
 
-    # Create an inbox ruleset
-    # Create a new inbox rule for forwarding, blocking, and allowing emails when sending and receiving
-    # @param create_inbox_ruleset_options [CreateInboxRulesetOptions] 
+    # Create a ruleset
+    # Create a new inbox or phone number rule for forwarding, blocking, and allowing emails or SMS when sending and receiving
+    # @param create_ruleset_options [CreateRulesetOptions] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :inbox_id Inbox id to attach ruleset to
-    # @return [Array<(InboxRulesetDto, Integer, Hash)>] InboxRulesetDto data, response status code and response headers
-    def create_new_inbox_ruleset_with_http_info(create_inbox_ruleset_options, opts = {})
+    # @option opts [String] :phone_id Phone id to attach ruleset to
+    # @return [Array<(RulesetDto, Integer, Hash)>] RulesetDto data, response status code and response headers
+    def create_new_ruleset_with_http_info(create_ruleset_options, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.create_new_inbox_ruleset ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.create_new_ruleset ...'
       end
-      # verify the required parameter 'create_inbox_ruleset_options' is set
-      if @api_client.config.client_side_validation && create_inbox_ruleset_options.nil?
-        fail ArgumentError, "Missing the required parameter 'create_inbox_ruleset_options' when calling InboxRulesetControllerApi.create_new_inbox_ruleset"
+      # verify the required parameter 'create_ruleset_options' is set
+      if @api_client.config.client_side_validation && create_ruleset_options.nil?
+        fail ArgumentError, "Missing the required parameter 'create_ruleset_options' when calling RulesetControllerApi.create_new_ruleset"
       end
       # resource path
       local_var_path = '/rulesets'
@@ -50,6 +52,7 @@ module MailSlurpClient
       # query parameters
       query_params = opts[:query_params] || {}
       query_params[:'inboxId'] = opts[:'inbox_id'] if !opts[:'inbox_id'].nil?
+      query_params[:'phoneId'] = opts[:'phone_id'] if !opts[:'phone_id'].nil?
 
       # header parameters
       header_params = opts[:header_params] || {}
@@ -62,10 +65,10 @@ module MailSlurpClient
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:body] || @api_client.object_to_http_body(create_inbox_ruleset_options) 
+      post_body = opts[:body] || @api_client.object_to_http_body(create_ruleset_options) 
 
       # return_type
-      return_type = opts[:return_type] || 'InboxRulesetDto' 
+      return_type = opts[:return_type] || 'RulesetDto' 
 
       # auth_names
       auth_names = opts[:auth_names] || ['API_KEY']
@@ -81,33 +84,33 @@ module MailSlurpClient
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#create_new_inbox_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#create_new_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Delete an inbox ruleset
-    # Delete inbox ruleset
-    # @param id [String] ID of inbox ruleset
+    # Delete a ruleset
+    # Delete ruleset
+    # @param id [String] ID of ruleset
     # @param [Hash] opts the optional parameters
     # @return [nil]
-    def delete_inbox_ruleset(id, opts = {})
-      delete_inbox_ruleset_with_http_info(id, opts)
+    def delete_ruleset(id, opts = {})
+      delete_ruleset_with_http_info(id, opts)
       nil
     end
 
-    # Delete an inbox ruleset
-    # Delete inbox ruleset
-    # @param id [String] ID of inbox ruleset
+    # Delete a ruleset
+    # Delete ruleset
+    # @param id [String] ID of ruleset
     # @param [Hash] opts the optional parameters
     # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
-    def delete_inbox_ruleset_with_http_info(id, opts = {})
+    def delete_ruleset_with_http_info(id, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.delete_inbox_ruleset ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.delete_ruleset ...'
       end
       # verify the required parameter 'id' is set
       if @api_client.config.client_side_validation && id.nil?
-        fail ArgumentError, "Missing the required parameter 'id' when calling InboxRulesetControllerApi.delete_inbox_ruleset"
+        fail ArgumentError, "Missing the required parameter 'id' when calling RulesetControllerApi.delete_ruleset"
       end
       # resource path
       local_var_path = '/rulesets/{id}'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
@@ -141,29 +144,31 @@ module MailSlurpClient
 
       data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#delete_inbox_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#delete_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Delete inbox rulesets
-    # Delete inbox rulesets. Accepts optional inboxId filter.
+    # Delete rulesets
+    # Delete rulesets. Accepts optional inboxId or phoneId filters.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :inbox_id Optional inbox id to attach ruleset to
+    # @option opts [String] :phone_id 
     # @return [nil]
-    def delete_inbox_rulesets(opts = {})
-      delete_inbox_rulesets_with_http_info(opts)
+    def delete_rulesets(opts = {})
+      delete_rulesets_with_http_info(opts)
       nil
     end
 
-    # Delete inbox rulesets
-    # Delete inbox rulesets. Accepts optional inboxId filter.
+    # Delete rulesets
+    # Delete rulesets. Accepts optional inboxId or phoneId filters.
     # @param [Hash] opts the optional parameters
     # @option opts [String] :inbox_id Optional inbox id to attach ruleset to
+    # @option opts [String] :phone_id 
     # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
-    def delete_inbox_rulesets_with_http_info(opts = {})
+    def delete_rulesets_with_http_info(opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.delete_inbox_rulesets ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.delete_rulesets ...'
       end
       # resource path
       local_var_path = '/rulesets'
@@ -171,6 +176,7 @@ module MailSlurpClient
       # query parameters
       query_params = opts[:query_params] || {}
       query_params[:'inboxId'] = opts[:'inbox_id'] if !opts[:'inbox_id'].nil?
+      query_params[:'phoneId'] = opts[:'phone_id'] if !opts[:'phone_id'].nil?
 
       # header parameters
       header_params = opts[:header_params] || {}
@@ -198,33 +204,33 @@ module MailSlurpClient
 
       data, status_code, headers = @api_client.call_api(:DELETE, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#delete_inbox_rulesets\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#delete_rulesets\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Get an inbox ruleset
-    # Get inbox ruleset
-    # @param id [String] ID of inbox ruleset
+    # Get a ruleset
+    # Get ruleset
+    # @param id [String] ID of ruleset
     # @param [Hash] opts the optional parameters
-    # @return [InboxRulesetDto]
-    def get_inbox_ruleset(id, opts = {})
-      data, _status_code, _headers = get_inbox_ruleset_with_http_info(id, opts)
+    # @return [RulesetDto]
+    def get_ruleset(id, opts = {})
+      data, _status_code, _headers = get_ruleset_with_http_info(id, opts)
       data
     end
 
-    # Get an inbox ruleset
-    # Get inbox ruleset
-    # @param id [String] ID of inbox ruleset
+    # Get a ruleset
+    # Get ruleset
+    # @param id [String] ID of ruleset
     # @param [Hash] opts the optional parameters
-    # @return [Array<(InboxRulesetDto, Integer, Hash)>] InboxRulesetDto data, response status code and response headers
-    def get_inbox_ruleset_with_http_info(id, opts = {})
+    # @return [Array<(RulesetDto, Integer, Hash)>] RulesetDto data, response status code and response headers
+    def get_ruleset_with_http_info(id, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.get_inbox_ruleset ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.get_ruleset ...'
       end
       # verify the required parameter 'id' is set
       if @api_client.config.client_side_validation && id.nil?
-        fail ArgumentError, "Missing the required parameter 'id' when calling InboxRulesetControllerApi.get_inbox_ruleset"
+        fail ArgumentError, "Missing the required parameter 'id' when calling RulesetControllerApi.get_ruleset"
       end
       # resource path
       local_var_path = '/rulesets/{id}'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
@@ -244,7 +250,7 @@ module MailSlurpClient
       post_body = opts[:body] 
 
       # return_type
-      return_type = opts[:return_type] || 'InboxRulesetDto' 
+      return_type = opts[:return_type] || 'RulesetDto' 
 
       # auth_names
       auth_names = opts[:auth_names] || ['API_KEY']
@@ -260,41 +266,43 @@ module MailSlurpClient
 
       data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#get_inbox_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#get_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # List inbox rulesets
-    # List all rulesets attached to an inbox
+    # List rulesets block and allow lists
+    # List all rulesets attached to an inbox or phone or account
     # @param [Hash] opts the optional parameters
     # @option opts [String] :inbox_id Optional inbox id to get rulesets from
+    # @option opts [String] :phone_id Optional phone id to get rulesets from
     # @option opts [Integer] :page Optional page index in inbox ruleset list pagination (default to 0)
     # @option opts [Integer] :size Optional page size in inbox ruleset list pagination (default to 20)
     # @option opts [String] :sort Optional createdAt sort direction ASC or DESC (default to 'ASC')
     # @option opts [String] :search_filter Optional search filter
     # @option opts [DateTime] :since Filter by created at after the given timestamp
     # @option opts [DateTime] :before Filter by created at before the given timestamp
-    # @return [PageInboxRulesetDto]
-    def get_inbox_rulesets(opts = {})
-      data, _status_code, _headers = get_inbox_rulesets_with_http_info(opts)
+    # @return [PageRulesetDto]
+    def get_rulesets(opts = {})
+      data, _status_code, _headers = get_rulesets_with_http_info(opts)
       data
     end
 
-    # List inbox rulesets
-    # List all rulesets attached to an inbox
+    # List rulesets block and allow lists
+    # List all rulesets attached to an inbox or phone or account
     # @param [Hash] opts the optional parameters
     # @option opts [String] :inbox_id Optional inbox id to get rulesets from
+    # @option opts [String] :phone_id Optional phone id to get rulesets from
     # @option opts [Integer] :page Optional page index in inbox ruleset list pagination
     # @option opts [Integer] :size Optional page size in inbox ruleset list pagination
     # @option opts [String] :sort Optional createdAt sort direction ASC or DESC
     # @option opts [String] :search_filter Optional search filter
     # @option opts [DateTime] :since Filter by created at after the given timestamp
     # @option opts [DateTime] :before Filter by created at before the given timestamp
-    # @return [Array<(PageInboxRulesetDto, Integer, Hash)>] PageInboxRulesetDto data, response status code and response headers
-    def get_inbox_rulesets_with_http_info(opts = {})
+    # @return [Array<(PageRulesetDto, Integer, Hash)>] PageRulesetDto data, response status code and response headers
+    def get_rulesets_with_http_info(opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.get_inbox_rulesets ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.get_rulesets ...'
       end
       allowable_values = ["ASC", "DESC"]
       if @api_client.config.client_side_validation && opts[:'sort'] && !allowable_values.include?(opts[:'sort'])
@@ -306,6 +314,7 @@ module MailSlurpClient
       # query parameters
       query_params = opts[:query_params] || {}
       query_params[:'inboxId'] = opts[:'inbox_id'] if !opts[:'inbox_id'].nil?
+      query_params[:'phoneId'] = opts[:'phone_id'] if !opts[:'phone_id'].nil?
       query_params[:'page'] = opts[:'page'] if !opts[:'page'].nil?
       query_params[:'size'] = opts[:'size'] if !opts[:'size'].nil?
       query_params[:'sort'] = opts[:'sort'] if !opts[:'sort'].nil?
@@ -325,7 +334,7 @@ module MailSlurpClient
       post_body = opts[:body] 
 
       # return_type
-      return_type = opts[:return_type] || 'PageInboxRulesetDto' 
+      return_type = opts[:return_type] || 'PageRulesetDto' 
 
       # auth_names
       auth_names = opts[:auth_names] || ['API_KEY']
@@ -341,45 +350,46 @@ module MailSlurpClient
 
       data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#get_inbox_rulesets\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#get_rulesets\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Test an inbox ruleset
-    # Test an inbox ruleset
-    # @param id [String] ID of inbox ruleset
-    # @param inbox_ruleset_test_options [InboxRulesetTestOptions] 
+    # Test inbox rulesets for inbox
+    # Test inbox rulesets for inbox
+    # @param inbox_id [String] ID of inbox
+    # @param ruleset_test_options [RulesetTestOptions] 
     # @param [Hash] opts the optional parameters
     # @return [InboxRulesetTestResult]
-    def test_inbox_ruleset(id, inbox_ruleset_test_options, opts = {})
-      data, _status_code, _headers = test_inbox_ruleset_with_http_info(id, inbox_ruleset_test_options, opts)
+    def test_inbox_rulesets_for_inbox(inbox_id, ruleset_test_options, opts = {})
+      data, _status_code, _headers = test_inbox_rulesets_for_inbox_with_http_info(inbox_id, ruleset_test_options, opts)
       data
     end
 
-    # Test an inbox ruleset
-    # Test an inbox ruleset
-    # @param id [String] ID of inbox ruleset
-    # @param inbox_ruleset_test_options [InboxRulesetTestOptions] 
+    # Test inbox rulesets for inbox
+    # Test inbox rulesets for inbox
+    # @param inbox_id [String] ID of inbox
+    # @param ruleset_test_options [RulesetTestOptions] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(InboxRulesetTestResult, Integer, Hash)>] InboxRulesetTestResult data, response status code and response headers
-    def test_inbox_ruleset_with_http_info(id, inbox_ruleset_test_options, opts = {})
+    def test_inbox_rulesets_for_inbox_with_http_info(inbox_id, ruleset_test_options, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.test_inbox_ruleset ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.test_inbox_rulesets_for_inbox ...'
       end
-      # verify the required parameter 'id' is set
-      if @api_client.config.client_side_validation && id.nil?
-        fail ArgumentError, "Missing the required parameter 'id' when calling InboxRulesetControllerApi.test_inbox_ruleset"
+      # verify the required parameter 'inbox_id' is set
+      if @api_client.config.client_side_validation && inbox_id.nil?
+        fail ArgumentError, "Missing the required parameter 'inbox_id' when calling RulesetControllerApi.test_inbox_rulesets_for_inbox"
       end
-      # verify the required parameter 'inbox_ruleset_test_options' is set
-      if @api_client.config.client_side_validation && inbox_ruleset_test_options.nil?
-        fail ArgumentError, "Missing the required parameter 'inbox_ruleset_test_options' when calling InboxRulesetControllerApi.test_inbox_ruleset"
+      # verify the required parameter 'ruleset_test_options' is set
+      if @api_client.config.client_side_validation && ruleset_test_options.nil?
+        fail ArgumentError, "Missing the required parameter 'ruleset_test_options' when calling RulesetControllerApi.test_inbox_rulesets_for_inbox"
       end
       # resource path
-      local_var_path = '/rulesets/{id}/test'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
+      local_var_path = '/rulesets'
 
       # query parameters
       query_params = opts[:query_params] || {}
+      query_params[:'inboxId'] = inbox_id
 
       # header parameters
       header_params = opts[:header_params] || {}
@@ -392,7 +402,7 @@ module MailSlurpClient
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:body] || @api_client.object_to_http_body(inbox_ruleset_test_options) 
+      post_body = opts[:body] || @api_client.object_to_http_body(ruleset_test_options) 
 
       # return_type
       return_type = opts[:return_type] || 'InboxRulesetTestResult' 
@@ -409,38 +419,38 @@ module MailSlurpClient
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:PUT, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#test_inbox_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#test_inbox_rulesets_for_inbox\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Test receiving with inbox rulesets
-    # Test whether inbound emails from an email address would be blocked or allowed by inbox rulesets
-    # @param test_inbox_ruleset_receiving_options [TestInboxRulesetReceivingOptions] 
+    # Test new ruleset
+    # Test new ruleset
+    # @param test_new_inbox_ruleset_options [TestNewInboxRulesetOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [TestInboxRulesetReceivingResult]
-    def test_inbox_ruleset_receiving(test_inbox_ruleset_receiving_options, opts = {})
-      data, _status_code, _headers = test_inbox_ruleset_receiving_with_http_info(test_inbox_ruleset_receiving_options, opts)
+    # @return [InboxRulesetTestResult]
+    def test_new_ruleset(test_new_inbox_ruleset_options, opts = {})
+      data, _status_code, _headers = test_new_ruleset_with_http_info(test_new_inbox_ruleset_options, opts)
       data
     end
 
-    # Test receiving with inbox rulesets
-    # Test whether inbound emails from an email address would be blocked or allowed by inbox rulesets
-    # @param test_inbox_ruleset_receiving_options [TestInboxRulesetReceivingOptions] 
+    # Test new ruleset
+    # Test new ruleset
+    # @param test_new_inbox_ruleset_options [TestNewInboxRulesetOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(TestInboxRulesetReceivingResult, Integer, Hash)>] TestInboxRulesetReceivingResult data, response status code and response headers
-    def test_inbox_ruleset_receiving_with_http_info(test_inbox_ruleset_receiving_options, opts = {})
+    # @return [Array<(InboxRulesetTestResult, Integer, Hash)>] InboxRulesetTestResult data, response status code and response headers
+    def test_new_ruleset_with_http_info(test_new_inbox_ruleset_options, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.test_inbox_ruleset_receiving ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.test_new_ruleset ...'
       end
-      # verify the required parameter 'test_inbox_ruleset_receiving_options' is set
-      if @api_client.config.client_side_validation && test_inbox_ruleset_receiving_options.nil?
-        fail ArgumentError, "Missing the required parameter 'test_inbox_ruleset_receiving_options' when calling InboxRulesetControllerApi.test_inbox_ruleset_receiving"
+      # verify the required parameter 'test_new_inbox_ruleset_options' is set
+      if @api_client.config.client_side_validation && test_new_inbox_ruleset_options.nil?
+        fail ArgumentError, "Missing the required parameter 'test_new_inbox_ruleset_options' when calling RulesetControllerApi.test_new_ruleset"
       end
       # resource path
-      local_var_path = '/rulesets/test-receiving'
+      local_var_path = '/rulesets'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -456,10 +466,10 @@ module MailSlurpClient
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:body] || @api_client.object_to_http_body(test_inbox_ruleset_receiving_options) 
+      post_body = opts[:body] || @api_client.object_to_http_body(test_new_inbox_ruleset_options) 
 
       # return_type
-      return_type = opts[:return_type] || 'TestInboxRulesetReceivingResult' 
+      return_type = opts[:return_type] || 'InboxRulesetTestResult' 
 
       # auth_names
       auth_names = opts[:auth_names] || ['API_KEY']
@@ -473,38 +483,44 @@ module MailSlurpClient
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#test_inbox_ruleset_receiving\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#test_new_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Test sending with inbox rulesets
-    # Test whether outbound emails to an email address would be blocked or allowed by inbox rulesets
-    # @param test_inbox_ruleset_sending_options [TestInboxRulesetSendingOptions] 
+    # Test a ruleset
+    # Test an inbox or phone ruleset
+    # @param id [String] ID of ruleset
+    # @param ruleset_test_options [RulesetTestOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [TestInboxRulesetSendingResult]
-    def test_inbox_ruleset_sending(test_inbox_ruleset_sending_options, opts = {})
-      data, _status_code, _headers = test_inbox_ruleset_sending_with_http_info(test_inbox_ruleset_sending_options, opts)
+    # @return [InboxRulesetTestResult]
+    def test_ruleset(id, ruleset_test_options, opts = {})
+      data, _status_code, _headers = test_ruleset_with_http_info(id, ruleset_test_options, opts)
       data
     end
 
-    # Test sending with inbox rulesets
-    # Test whether outbound emails to an email address would be blocked or allowed by inbox rulesets
-    # @param test_inbox_ruleset_sending_options [TestInboxRulesetSendingOptions] 
+    # Test a ruleset
+    # Test an inbox or phone ruleset
+    # @param id [String] ID of ruleset
+    # @param ruleset_test_options [RulesetTestOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(TestInboxRulesetSendingResult, Integer, Hash)>] TestInboxRulesetSendingResult data, response status code and response headers
-    def test_inbox_ruleset_sending_with_http_info(test_inbox_ruleset_sending_options, opts = {})
+    # @return [Array<(InboxRulesetTestResult, Integer, Hash)>] InboxRulesetTestResult data, response status code and response headers
+    def test_ruleset_with_http_info(id, ruleset_test_options, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.test_inbox_ruleset_sending ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.test_ruleset ...'
       end
-      # verify the required parameter 'test_inbox_ruleset_sending_options' is set
-      if @api_client.config.client_side_validation && test_inbox_ruleset_sending_options.nil?
-        fail ArgumentError, "Missing the required parameter 'test_inbox_ruleset_sending_options' when calling InboxRulesetControllerApi.test_inbox_ruleset_sending"
+      # verify the required parameter 'id' is set
+      if @api_client.config.client_side_validation && id.nil?
+        fail ArgumentError, "Missing the required parameter 'id' when calling RulesetControllerApi.test_ruleset"
+      end
+      # verify the required parameter 'ruleset_test_options' is set
+      if @api_client.config.client_side_validation && ruleset_test_options.nil?
+        fail ArgumentError, "Missing the required parameter 'ruleset_test_options' when calling RulesetControllerApi.test_ruleset"
       end
       # resource path
-      local_var_path = '/rulesets/test-sending'
+      local_var_path = '/rulesets/{id}/test'.sub('{' + 'id' + '}', CGI.escape(id.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -520,10 +536,10 @@ module MailSlurpClient
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:body] || @api_client.object_to_http_body(test_inbox_ruleset_sending_options) 
+      post_body = opts[:body] || @api_client.object_to_http_body(ruleset_test_options) 
 
       # return_type
-      return_type = opts[:return_type] || 'TestInboxRulesetSendingResult' 
+      return_type = opts[:return_type] || 'InboxRulesetTestResult' 
 
       # auth_names
       auth_names = opts[:auth_names] || ['API_KEY']
@@ -539,46 +555,39 @@ module MailSlurpClient
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#test_inbox_ruleset_sending\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#test_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Test inbox rulesets for inbox
-    # Test inbox rulesets for inbox
-    # @param inbox_id [String] ID of inbox
-    # @param inbox_ruleset_test_options [InboxRulesetTestOptions] 
+    # Test receiving with rulesets
+    # Test whether inbound emails from an email address would be blocked or allowed by inbox rulesets or test if phone number can receive SMS
+    # @param test_ruleset_receiving_options [TestRulesetReceivingOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [InboxRulesetTestResult]
-    def test_inbox_rulesets_for_inbox(inbox_id, inbox_ruleset_test_options, opts = {})
-      data, _status_code, _headers = test_inbox_rulesets_for_inbox_with_http_info(inbox_id, inbox_ruleset_test_options, opts)
+    # @return [TestRulesetReceivingResult]
+    def test_ruleset_receiving(test_ruleset_receiving_options, opts = {})
+      data, _status_code, _headers = test_ruleset_receiving_with_http_info(test_ruleset_receiving_options, opts)
       data
     end
 
-    # Test inbox rulesets for inbox
-    # Test inbox rulesets for inbox
-    # @param inbox_id [String] ID of inbox
-    # @param inbox_ruleset_test_options [InboxRulesetTestOptions] 
+    # Test receiving with rulesets
+    # Test whether inbound emails from an email address would be blocked or allowed by inbox rulesets or test if phone number can receive SMS
+    # @param test_ruleset_receiving_options [TestRulesetReceivingOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(InboxRulesetTestResult, Integer, Hash)>] InboxRulesetTestResult data, response status code and response headers
-    def test_inbox_rulesets_for_inbox_with_http_info(inbox_id, inbox_ruleset_test_options, opts = {})
+    # @return [Array<(TestRulesetReceivingResult, Integer, Hash)>] TestRulesetReceivingResult data, response status code and response headers
+    def test_ruleset_receiving_with_http_info(test_ruleset_receiving_options, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.test_inbox_rulesets_for_inbox ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.test_ruleset_receiving ...'
       end
-      # verify the required parameter 'inbox_id' is set
-      if @api_client.config.client_side_validation && inbox_id.nil?
-        fail ArgumentError, "Missing the required parameter 'inbox_id' when calling InboxRulesetControllerApi.test_inbox_rulesets_for_inbox"
-      end
-      # verify the required parameter 'inbox_ruleset_test_options' is set
-      if @api_client.config.client_side_validation && inbox_ruleset_test_options.nil?
-        fail ArgumentError, "Missing the required parameter 'inbox_ruleset_test_options' when calling InboxRulesetControllerApi.test_inbox_rulesets_for_inbox"
+      # verify the required parameter 'test_ruleset_receiving_options' is set
+      if @api_client.config.client_side_validation && test_ruleset_receiving_options.nil?
+        fail ArgumentError, "Missing the required parameter 'test_ruleset_receiving_options' when calling RulesetControllerApi.test_ruleset_receiving"
       end
       # resource path
-      local_var_path = '/rulesets'
+      local_var_path = '/rulesets/test-receiving'
 
       # query parameters
       query_params = opts[:query_params] || {}
-      query_params[:'inboxId'] = inbox_id
 
       # header parameters
       header_params = opts[:header_params] || {}
@@ -591,10 +600,10 @@ module MailSlurpClient
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:body] || @api_client.object_to_http_body(inbox_ruleset_test_options) 
+      post_body = opts[:body] || @api_client.object_to_http_body(test_ruleset_receiving_options) 
 
       # return_type
-      return_type = opts[:return_type] || 'InboxRulesetTestResult' 
+      return_type = opts[:return_type] || 'TestRulesetReceivingResult' 
 
       # auth_names
       auth_names = opts[:auth_names] || ['API_KEY']
@@ -608,38 +617,38 @@ module MailSlurpClient
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:PUT, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#test_inbox_rulesets_for_inbox\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#test_ruleset_receiving\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Test new inbox ruleset
-    # Test new inbox ruleset
-    # @param test_new_inbox_ruleset_options [TestNewInboxRulesetOptions] 
+    # Test sending with rulesets
+    # Test whether outbound emails to an email address would be blocked or allowed by inbox rulesets or whether a phone number can send SMS
+    # @param test_inbox_ruleset_sending_options [TestInboxRulesetSendingOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [InboxRulesetTestResult]
-    def test_new_inbox_ruleset(test_new_inbox_ruleset_options, opts = {})
-      data, _status_code, _headers = test_new_inbox_ruleset_with_http_info(test_new_inbox_ruleset_options, opts)
+    # @return [TestRulesetSendingResult]
+    def test_ruleset_sending(test_inbox_ruleset_sending_options, opts = {})
+      data, _status_code, _headers = test_ruleset_sending_with_http_info(test_inbox_ruleset_sending_options, opts)
       data
     end
 
-    # Test new inbox ruleset
-    # Test new inbox ruleset
-    # @param test_new_inbox_ruleset_options [TestNewInboxRulesetOptions] 
+    # Test sending with rulesets
+    # Test whether outbound emails to an email address would be blocked or allowed by inbox rulesets or whether a phone number can send SMS
+    # @param test_inbox_ruleset_sending_options [TestInboxRulesetSendingOptions] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(InboxRulesetTestResult, Integer, Hash)>] InboxRulesetTestResult data, response status code and response headers
-    def test_new_inbox_ruleset_with_http_info(test_new_inbox_ruleset_options, opts = {})
+    # @return [Array<(TestRulesetSendingResult, Integer, Hash)>] TestRulesetSendingResult data, response status code and response headers
+    def test_ruleset_sending_with_http_info(test_inbox_ruleset_sending_options, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: InboxRulesetControllerApi.test_new_inbox_ruleset ...'
+        @api_client.config.logger.debug 'Calling API: RulesetControllerApi.test_ruleset_sending ...'
       end
-      # verify the required parameter 'test_new_inbox_ruleset_options' is set
-      if @api_client.config.client_side_validation && test_new_inbox_ruleset_options.nil?
-        fail ArgumentError, "Missing the required parameter 'test_new_inbox_ruleset_options' when calling InboxRulesetControllerApi.test_new_inbox_ruleset"
+      # verify the required parameter 'test_inbox_ruleset_sending_options' is set
+      if @api_client.config.client_side_validation && test_inbox_ruleset_sending_options.nil?
+        fail ArgumentError, "Missing the required parameter 'test_inbox_ruleset_sending_options' when calling RulesetControllerApi.test_ruleset_sending"
       end
       # resource path
-      local_var_path = '/rulesets'
+      local_var_path = '/rulesets/test-sending'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -655,10 +664,10 @@ module MailSlurpClient
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:body] || @api_client.object_to_http_body(test_new_inbox_ruleset_options) 
+      post_body = opts[:body] || @api_client.object_to_http_body(test_inbox_ruleset_sending_options) 
 
       # return_type
-      return_type = opts[:return_type] || 'InboxRulesetTestResult' 
+      return_type = opts[:return_type] || 'TestRulesetSendingResult' 
 
       # auth_names
       auth_names = opts[:auth_names] || ['API_KEY']
@@ -672,9 +681,9 @@ module MailSlurpClient
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:PATCH, local_var_path, new_options)
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: InboxRulesetControllerApi#test_new_inbox_ruleset\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: RulesetControllerApi#test_ruleset_sending\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end