lockally 0.2.0 → 0.3.1

data/lib/lockally/api/domains_api.rb

@@ -19,31 +19,31 @@ module Lockally
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     end
-    # Delete a domain
-    # Removes the domain registration. Refuses with 409 if any mailbox is still attached — delete the mailboxes first. 
-    # @param domain [String] 
+    # Register a domain
+    # Registers a new domain for the calling tenant. Generates a DKIM keypair and verification token. Returns DNS instructions the tenant must publish under their own DNS (verification TXT, SPF include, DKIM TXT, MX records to `mx1`/`mx2.lockally.com`, DMARC seed).  **Idempotent** — re-posting the same domain returns the existing record with the same DKIM keys and token (regenerating would break the tenant's published DNS). Returns 200 on idempotent hit, 201 on first create.  Returns 409 if the domain is already claimed by a different tenant. 
+    # @param create_domain_request [CreateDomainRequest] 
     # @param [Hash] opts the optional parameters
-    # @return [nil]
-    def v1_domains_domain_delete(domain, opts = {})
-      v1_domains_domain_delete_with_http_info(domain, opts)
-      nil
+    # @return [Domain]
+    def create_domain(create_domain_request, opts = {})
+      data, _status_code, _headers = create_domain_with_http_info(create_domain_request, opts)
+      data
     end
 
-    # Delete a domain
-    # Removes the domain registration. Refuses with 409 if any mailbox is still attached — delete the mailboxes first. 
-    # @param domain [String] 
+    # Register a domain
+    # Registers a new domain for the calling tenant. Generates a DKIM keypair and verification token. Returns DNS instructions the tenant must publish under their own DNS (verification TXT, SPF include, DKIM TXT, MX records to `mx1`/`mx2.lockally.com`, DMARC seed).  **Idempotent** — re-posting the same domain returns the existing record with the same DKIM keys and token (regenerating would break the tenant's published DNS). Returns 200 on idempotent hit, 201 on first create.  Returns 409 if the domain is already claimed by a different tenant. 
+    # @param create_domain_request [CreateDomainRequest] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
-    def v1_domains_domain_delete_with_http_info(domain, opts = {})
+    # @return [Array<(Domain, Integer, Hash)>] Domain data, response status code and response headers
+    def create_domain_with_http_info(create_domain_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_domain_delete ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.create_domain ...'
       end
-      # verify the required parameter 'domain' is set
-      if @api_client.config.client_side_validation && domain.nil?
-        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.v1_domains_domain_delete"
+      # verify the required parameter 'create_domain_request' is set
+      if @api_client.config.client_side_validation && create_domain_request.nil?
+        fail ArgumentError, "Missing the required parameter 'create_domain_request' when calling DomainsApi.create_domain"
       end
       # resource path
-      local_var_path = '/v1/domains/{domain}'.sub('{domain}', CGI.escape(domain.to_s))
+      local_var_path = '/v1/domains'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -51,22 +51,27 @@ module Lockally
       # header parameters
       header_params = opts[:header_params] || {}
       # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/problem+json']) unless header_params['Accept']
+      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'application/problem+json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body]
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(create_domain_request)
 
       # return_type
-      return_type = opts[:debug_return_type]
+      return_type = opts[:debug_return_type] || 'Domain'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_delete",
+        :operation => :"DomainsApi.create_domain",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -75,33 +80,35 @@ module Lockally
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:DELETE, 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: DomainsApi#v1_domains_domain_delete\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#create_domain\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Get a domain
+    # Delete a domain
+    # Removes the domain registration. Refuses with 409 if any mailbox is still attached — delete the mailboxes first. 
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [Domain]
-    def v1_domains_domain_get(domain, opts = {})
-      data, _status_code, _headers = v1_domains_domain_get_with_http_info(domain, opts)
-      data
+    # @return [nil]
+    def delete_domain(domain, opts = {})
+      delete_domain_with_http_info(domain, opts)
+      nil
     end
 
-    # Get a domain
+    # Delete a domain
+    # Removes the domain registration. Refuses with 409 if any mailbox is still attached — delete the mailboxes first. 
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(Domain, Integer, Hash)>] Domain data, response status code and response headers
-    def v1_domains_domain_get_with_http_info(domain, opts = {})
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def delete_domain_with_http_info(domain, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_domain_get ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.delete_domain ...'
       end
       # verify the required parameter 'domain' is set
       if @api_client.config.client_side_validation && domain.nil?
-        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.v1_domains_domain_get"
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.delete_domain"
       end
       # resource path
       local_var_path = '/v1/domains/{domain}'.sub('{domain}', CGI.escape(domain.to_s))
@@ -112,7 +119,7 @@ module Lockally
       # header parameters
       header_params = opts[:header_params] || {}
       # HTTP header 'Accept' (if needed)
-      header_params['Accept'] = @api_client.select_header_accept(['application/json', 'application/problem+json']) unless header_params['Accept']
+      header_params['Accept'] = @api_client.select_header_accept(['application/problem+json']) unless header_params['Accept']
 
       # form parameters
       form_params = opts[:form_params] || {}
@@ -121,13 +128,13 @@ module Lockally
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Domain'
+      return_type = opts[:debug_return_type]
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_get",
+        :operation => :"DomainsApi.delete_domain",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -136,9 +143,9 @@ module Lockally
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      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: DomainsApi#v1_domains_domain_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#delete_domain\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -148,8 +155,8 @@ module Lockally
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
     # @return [nil]
-    def v1_domains_domain_return_path_delete(domain, opts = {})
-      v1_domains_domain_return_path_delete_with_http_info(domain, opts)
+    def disable_return_path(domain, opts = {})
+      disable_return_path_with_http_info(domain, opts)
       nil
     end
 
@@ -158,13 +165,13 @@ module Lockally
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
-    def v1_domains_domain_return_path_delete_with_http_info(domain, opts = {})
+    def disable_return_path_with_http_info(domain, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_domain_return_path_delete ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.disable_return_path ...'
       end
       # verify the required parameter 'domain' is set
       if @api_client.config.client_side_validation && domain.nil?
-        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.v1_domains_domain_return_path_delete"
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.disable_return_path"
       end
       # resource path
       local_var_path = '/v1/domains/{domain}/return-path'.sub('{domain}', CGI.escape(domain.to_s))
@@ -190,7 +197,7 @@ module Lockally
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_return_path_delete",
+        :operation => :"DomainsApi.disable_return_path",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -201,33 +208,33 @@ module Lockally
 
       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: DomainsApi#v1_domains_domain_return_path_delete\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#disable_return_path\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Get the custom Return-Path
-    # A custom Return-Path moves the envelope sender of mail sent through the API from this domain onto `bounces.<domain>`. Bounce reports then come back to Lockally instead of the sending mailbox, and a bounce that arrives after delivery marks the message bounced, suppresses the address and fires `delivery.bounced`. Mail sent from webmail or mail apps is not affected. DKIM stays signed by the domain itself. `status` is `off`, `pending` (records not confirmed yet) or `active`. 
+    # Turn on the custom Return-Path
+    # Moves it to `pending` and returns the two records to publish on `bounces.<domain>`. Nothing changes for mail until they are confirmed with the verify call. The domain must be verified. Available on every plan except Free. 
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
     # @return [ReturnPath]
-    def v1_domains_domain_return_path_get(domain, opts = {})
-      data, _status_code, _headers = v1_domains_domain_return_path_get_with_http_info(domain, opts)
+    def enable_return_path(domain, opts = {})
+      data, _status_code, _headers = enable_return_path_with_http_info(domain, opts)
       data
     end
 
-    # Get the custom Return-Path
-    # A custom Return-Path moves the envelope sender of mail sent through the API from this domain onto &#x60;bounces.&lt;domain&gt;&#x60;. Bounce reports then come back to Lockally instead of the sending mailbox, and a bounce that arrives after delivery marks the message bounced, suppresses the address and fires &#x60;delivery.bounced&#x60;. Mail sent from webmail or mail apps is not affected. DKIM stays signed by the domain itself. &#x60;status&#x60; is &#x60;off&#x60;, &#x60;pending&#x60; (records not confirmed yet) or &#x60;active&#x60;. 
+    # Turn on the custom Return-Path
+    # Moves it to &#x60;pending&#x60; and returns the two records to publish on &#x60;bounces.&lt;domain&gt;&#x60;. Nothing changes for mail until they are confirmed with the verify call. The domain must be verified. Available on every plan except Free. 
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(ReturnPath, Integer, Hash)>] ReturnPath data, response status code and response headers
-    def v1_domains_domain_return_path_get_with_http_info(domain, opts = {})
+    def enable_return_path_with_http_info(domain, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_domain_return_path_get ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.enable_return_path ...'
       end
       # verify the required parameter 'domain' is set
       if @api_client.config.client_side_validation && domain.nil?
-        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.v1_domains_domain_return_path_get"
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.enable_return_path"
       end
       # resource path
       local_var_path = '/v1/domains/{domain}/return-path'.sub('{domain}', CGI.escape(domain.to_s))
@@ -253,7 +260,7 @@ module Lockally
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_return_path_get",
+        :operation => :"DomainsApi.enable_return_path",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -262,38 +269,36 @@ module Lockally
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:GET, 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: DomainsApi#v1_domains_domain_return_path_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#enable_return_path\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Turn on the custom Return-Path
-    # Moves it to `pending` and returns the two records to publish on `bounces.<domain>`. Nothing changes for mail until they are confirmed with the verify call. The domain must be verified. Available on every plan except Free. 
+    # Get a domain
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [ReturnPath]
-    def v1_domains_domain_return_path_post(domain, opts = {})
-      data, _status_code, _headers = v1_domains_domain_return_path_post_with_http_info(domain, opts)
+    # @return [Domain]
+    def get_domain(domain, opts = {})
+      data, _status_code, _headers = get_domain_with_http_info(domain, opts)
       data
     end
 
-    # Turn on the custom Return-Path
-    # Moves it to &#x60;pending&#x60; and returns the two records to publish on &#x60;bounces.&lt;domain&gt;&#x60;. Nothing changes for mail until they are confirmed with the verify call. The domain must be verified. Available on every plan except Free. 
+    # Get a domain
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(ReturnPath, Integer, Hash)>] ReturnPath data, response status code and response headers
-    def v1_domains_domain_return_path_post_with_http_info(domain, opts = {})
+    # @return [Array<(Domain, Integer, Hash)>] Domain data, response status code and response headers
+    def get_domain_with_http_info(domain, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_domain_return_path_post ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.get_domain ...'
       end
       # verify the required parameter 'domain' is set
       if @api_client.config.client_side_validation && domain.nil?
-        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.v1_domains_domain_return_path_post"
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.get_domain"
       end
       # resource path
-      local_var_path = '/v1/domains/{domain}/return-path'.sub('{domain}', CGI.escape(domain.to_s))
+      local_var_path = '/v1/domains/{domain}'.sub('{domain}', CGI.escape(domain.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -310,13 +315,13 @@ module Lockally
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'ReturnPath'
+      return_type = opts[:debug_return_type] || 'Domain'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_return_path_post",
+        :operation => :"DomainsApi.get_domain",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -325,38 +330,38 @@ module Lockally
         :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(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: DomainsApi#v1_domains_domain_return_path_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#get_domain\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Check the custom Return-Path records
-    # Looks up the MX and SPF records on `bounces.<domain>`. Returns 200 either way: while a record is missing the status stays `pending` and `check` says which one. Once both are found the Return-Path becomes `active` and the send path starts using it. 
+    # Get the custom Return-Path
+    # A custom Return-Path moves the envelope sender of mail sent through the API from this domain onto `bounces.<domain>`. Bounce reports then come back to Lockally instead of the sending mailbox, and a bounce that arrives after delivery marks the message bounced, suppresses the address and fires `delivery.bounced`. Mail sent from webmail or mail apps is not affected. DKIM stays signed by the domain itself. `status` is `off`, `pending` (records not confirmed yet) or `active`. 
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
     # @return [ReturnPath]
-    def v1_domains_domain_return_path_verify_post(domain, opts = {})
-      data, _status_code, _headers = v1_domains_domain_return_path_verify_post_with_http_info(domain, opts)
+    def get_return_path(domain, opts = {})
+      data, _status_code, _headers = get_return_path_with_http_info(domain, opts)
       data
     end
 
-    # Check the custom Return-Path records
-    # Looks up the MX and SPF records on &#x60;bounces.&lt;domain&gt;&#x60;. Returns 200 either way: while a record is missing the status stays &#x60;pending&#x60; and &#x60;check&#x60; says which one. Once both are found the Return-Path becomes &#x60;active&#x60; and the send path starts using it. 
+    # Get the custom Return-Path
+    # A custom Return-Path moves the envelope sender of mail sent through the API from this domain onto &#x60;bounces.&lt;domain&gt;&#x60;. Bounce reports then come back to Lockally instead of the sending mailbox, and a bounce that arrives after delivery marks the message bounced, suppresses the address and fires &#x60;delivery.bounced&#x60;. Mail sent from webmail or mail apps is not affected. DKIM stays signed by the domain itself. &#x60;status&#x60; is &#x60;off&#x60;, &#x60;pending&#x60; (records not confirmed yet) or &#x60;active&#x60;. 
     # @param domain [String] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(ReturnPath, Integer, Hash)>] ReturnPath data, response status code and response headers
-    def v1_domains_domain_return_path_verify_post_with_http_info(domain, opts = {})
+    def get_return_path_with_http_info(domain, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_domain_return_path_verify_post ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.get_return_path ...'
       end
       # verify the required parameter 'domain' is set
       if @api_client.config.client_side_validation && domain.nil?
-        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.v1_domains_domain_return_path_verify_post"
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.get_return_path"
       end
       # resource path
-      local_var_path = '/v1/domains/{domain}/return-path/verify'.sub('{domain}', CGI.escape(domain.to_s))
+      local_var_path = '/v1/domains/{domain}/return-path'.sub('{domain}', CGI.escape(domain.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -379,7 +384,7 @@ module Lockally
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_return_path_verify_post",
+        :operation => :"DomainsApi.get_return_path",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -388,38 +393,32 @@ module Lockally
         :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(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: DomainsApi#v1_domains_domain_return_path_verify_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#get_return_path\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Force-poll DNS verification
-    # Synchronously checks the `_lockally-verify.<domain>` TXT record against the stored verification token. Returns 200 either way: the returned `verified` boolean tells you whether DNS now confirms. Caller polls until `verified: true`. In v2 a background worker auto-polls and fires a `domain.verified` webhook. 
-    # @param domain [String] 
+    # List domains
+    # Returns every domain registered under the calling tenant.
     # @param [Hash] opts the optional parameters
-    # @return [Domain]
-    def v1_domains_domain_verify_post(domain, opts = {})
-      data, _status_code, _headers = v1_domains_domain_verify_post_with_http_info(domain, opts)
+    # @return [ListDomains200Response]
+    def list_domains(opts = {})
+      data, _status_code, _headers = list_domains_with_http_info(opts)
       data
     end
 
-    # Force-poll DNS verification
-    # Synchronously checks the &#x60;_lockally-verify.&lt;domain&gt;&#x60; TXT record against the stored verification token. Returns 200 either way: the returned &#x60;verified&#x60; boolean tells you whether DNS now confirms. Caller polls until &#x60;verified: true&#x60;. In v2 a background worker auto-polls and fires a &#x60;domain.verified&#x60; webhook. 
-    # @param domain [String] 
+    # List domains
+    # Returns every domain registered under the calling tenant.
     # @param [Hash] opts the optional parameters
-    # @return [Array<(Domain, Integer, Hash)>] Domain data, response status code and response headers
-    def v1_domains_domain_verify_post_with_http_info(domain, opts = {})
+    # @return [Array<(ListDomains200Response, Integer, Hash)>] ListDomains200Response data, response status code and response headers
+    def list_domains_with_http_info(opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_domain_verify_post ...'
-      end
-      # verify the required parameter 'domain' is set
-      if @api_client.config.client_side_validation && domain.nil?
-        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.v1_domains_domain_verify_post"
+        @api_client.config.logger.debug 'Calling API: DomainsApi.list_domains ...'
       end
       # resource path
-      local_var_path = '/v1/domains/{domain}/verify'.sub('{domain}', CGI.escape(domain.to_s))
+      local_var_path = '/v1/domains'
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -436,13 +435,13 @@ module Lockally
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Domain'
+      return_type = opts[:debug_return_type] || 'ListDomains200Response'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_verify_post",
+        :operation => :"DomainsApi.list_domains",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -451,32 +450,38 @@ module Lockally
         :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(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: DomainsApi#v1_domains_domain_verify_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#list_domains\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # List domains
-    # Returns every domain registered under the calling tenant.
+    # Force-poll DNS verification
+    # Synchronously checks the `_lockally-verify.<domain>` TXT record against the stored verification token. Returns 200 either way: the returned `verified` boolean tells you whether DNS now confirms. Caller polls until `verified: true`. In v2 a background worker auto-polls and fires a `domain.verified` webhook. 
+    # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [V1DomainsGet200Response]
-    def v1_domains_get(opts = {})
-      data, _status_code, _headers = v1_domains_get_with_http_info(opts)
+    # @return [Domain]
+    def verify_domain(domain, opts = {})
+      data, _status_code, _headers = verify_domain_with_http_info(domain, opts)
       data
     end
 
-    # List domains
-    # Returns every domain registered under the calling tenant.
+    # Force-poll DNS verification
+    # Synchronously checks the &#x60;_lockally-verify.&lt;domain&gt;&#x60; TXT record against the stored verification token. Returns 200 either way: the returned &#x60;verified&#x60; boolean tells you whether DNS now confirms. Caller polls until &#x60;verified: true&#x60;. In v2 a background worker auto-polls and fires a &#x60;domain.verified&#x60; webhook. 
+    # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(V1DomainsGet200Response, Integer, Hash)>] V1DomainsGet200Response data, response status code and response headers
-    def v1_domains_get_with_http_info(opts = {})
+    # @return [Array<(Domain, Integer, Hash)>] Domain data, response status code and response headers
+    def verify_domain_with_http_info(domain, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_get ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.verify_domain ...'
+      end
+      # verify the required parameter 'domain' is set
+      if @api_client.config.client_side_validation && domain.nil?
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.verify_domain"
       end
       # resource path
-      local_var_path = '/v1/domains'
+      local_var_path = '/v1/domains/{domain}/verify'.sub('{domain}', CGI.escape(domain.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -493,13 +498,13 @@ module Lockally
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'V1DomainsGet200Response'
+      return_type = opts[:debug_return_type] || 'Domain'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_get",
+        :operation => :"DomainsApi.verify_domain",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -508,38 +513,38 @@ module Lockally
         :return_type => return_type
       )
 
-      data, status_code, headers = @api_client.call_api(:GET, 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: DomainsApi#v1_domains_get\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#verify_domain\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
-    # Register a domain
-    # Registers a new domain for the calling tenant. Generates a DKIM keypair and verification token. Returns DNS instructions the tenant must publish under their own DNS (verification TXT, SPF include, DKIM TXT, MX records to `mx1`/`mx2.lockally.com`, DMARC seed).  **Idempotent** — re-posting the same domain returns the existing record with the same DKIM keys and token (regenerating would break the tenant's published DNS). Returns 200 on idempotent hit, 201 on first create.  Returns 409 if the domain is already claimed by a different tenant. 
-    # @param v1_domains_post_request [V1DomainsPostRequest] 
+    # Check the custom Return-Path records
+    # Looks up the MX and SPF records on `bounces.<domain>`. Returns 200 either way: while a record is missing the status stays `pending` and `check` says which one. Once both are found the Return-Path becomes `active` and the send path starts using it. 
+    # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [Domain]
-    def v1_domains_post(v1_domains_post_request, opts = {})
-      data, _status_code, _headers = v1_domains_post_with_http_info(v1_domains_post_request, opts)
+    # @return [ReturnPath]
+    def verify_return_path(domain, opts = {})
+      data, _status_code, _headers = verify_return_path_with_http_info(domain, opts)
       data
     end
 
-    # Register a domain
-    # Registers a new domain for the calling tenant. Generates a DKIM keypair and verification token. Returns DNS instructions the tenant must publish under their own DNS (verification TXT, SPF include, DKIM TXT, MX records to &#x60;mx1&#x60;/&#x60;mx2.lockally.com&#x60;, DMARC seed).  **Idempotent** — re-posting the same domain returns the existing record with the same DKIM keys and token (regenerating would break the tenant&#39;s published DNS). Returns 200 on idempotent hit, 201 on first create.  Returns 409 if the domain is already claimed by a different tenant. 
-    # @param v1_domains_post_request [V1DomainsPostRequest] 
+    # Check the custom Return-Path records
+    # Looks up the MX and SPF records on &#x60;bounces.&lt;domain&gt;&#x60;. Returns 200 either way: while a record is missing the status stays &#x60;pending&#x60; and &#x60;check&#x60; says which one. Once both are found the Return-Path becomes &#x60;active&#x60; and the send path starts using it. 
+    # @param domain [String] 
     # @param [Hash] opts the optional parameters
-    # @return [Array<(Domain, Integer, Hash)>] Domain data, response status code and response headers
-    def v1_domains_post_with_http_info(v1_domains_post_request, opts = {})
+    # @return [Array<(ReturnPath, Integer, Hash)>] ReturnPath data, response status code and response headers
+    def verify_return_path_with_http_info(domain, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: DomainsApi.v1_domains_post ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.verify_return_path ...'
       end
-      # verify the required parameter 'v1_domains_post_request' is set
-      if @api_client.config.client_side_validation && v1_domains_post_request.nil?
-        fail ArgumentError, "Missing the required parameter 'v1_domains_post_request' when calling DomainsApi.v1_domains_post"
+      # verify the required parameter 'domain' is set
+      if @api_client.config.client_side_validation && domain.nil?
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.verify_return_path"
       end
       # resource path
-      local_var_path = '/v1/domains'
+      local_var_path = '/v1/domains/{domain}/return-path/verify'.sub('{domain}', CGI.escape(domain.to_s))
 
       # query parameters
       query_params = opts[:query_params] || {}
@@ -548,26 +553,21 @@ module Lockally
       header_params = opts[:header_params] || {}
       # HTTP header 'Accept' (if needed)
       header_params['Accept'] = @api_client.select_header_accept(['application/json', 'application/problem+json']) unless header_params['Accept']
-      # HTTP header 'Content-Type'
-      content_type = @api_client.select_header_content_type(['application/json'])
-      if !content_type.nil?
-          header_params['Content-Type'] = content_type
-      end
 
       # form parameters
       form_params = opts[:form_params] || {}
 
       # http body (model)
-      post_body = opts[:debug_body] || @api_client.object_to_http_body(v1_domains_post_request)
+      post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'Domain'
+      return_type = opts[:debug_return_type] || 'ReturnPath'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_post",
+        :operation => :"DomainsApi.verify_return_path",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -578,7 +578,7 @@ module Lockally
 
       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: DomainsApi#v1_domains_post\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: DomainsApi#verify_return_path\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end