lockally 0.1.0 → 0.3.0

data/lib/lockally/api/domains_api.rb

@@ -1,7 +1,7 @@
 =begin
 #lockally control plane
 
-#The lockally control plane lets integrators and direct customers manage everything except actual mail data flow (which uses standard JMAP / IMAP / SMTP-submission against the data plane endpoints).  **Authentication.** All `/v1/*` endpoints require a Bearer API key in the `Authorization` header. Keys are formatted `lk_live_<8-char-prefix>_<32-char-secret>`. Generate the first key for a tenant via `cmd/seed`; subsequent keys via `POST /v1/api-keys`.  **Errors.** Failures return [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) `application/problem+json` documents.  **Scopes.** Each endpoint requires a specific scope on the presented key. Insufficient scope returns `403` with the required scope name in `detail`. 
+#The lockally control plane lets integrators and direct customers manage everything except actual mail data flow (which uses standard JMAP / IMAP / SMTP-submission against the data plane endpoints).  **Authentication.** All `/v1/*` endpoints require a Bearer API key in the `Authorization` header. Keys are formatted `lk_live_<8-char-prefix>_<32-char-secret>`, or `lk_test_<...>` for a test key. Create keys in the dashboard, or with `POST /v1/api-keys` using a key that holds `tenant:admin`.  The key's plan is checked on every request, so a key stops working if the account moves to a plan without API access, and works again if it moves back.  **Errors.** Failures return [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) `application/problem+json` documents.  **Scopes.** Each endpoint requires a specific scope on the presented key. Insufficient scope returns `403` with the required scope name in `detail`. 
 
 The version of the OpenAPI document: 0.1.0
 Contact: support@lockally.com
@@ -19,13 +19,81 @@ module Lockally
     def initialize(api_client = ApiClient.default)
       @api_client = api_client
     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 create_domain_request [CreateDomainRequest] 
+    # @param [Hash] opts the optional parameters
+    # @return [Domain]
+    def create_domain(create_domain_request, opts = {})
+      data, _status_code, _headers = create_domain_with_http_info(create_domain_request, 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 create_domain_request [CreateDomainRequest] 
+    # @param [Hash] opts the optional parameters
+    # @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.create_domain ...'
+      end
+      # 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'
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # 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']
+      # 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(create_domain_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'Domain'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['bearerAuth']
+
+      new_options = opts.merge(
+        :operation => :"DomainsApi.create_domain",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      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#create_domain\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
     # 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 [nil]
-    def v1_domains_domain_delete(domain, opts = {})
-      v1_domains_domain_delete_with_http_info(domain, opts)
+    def delete_domain(domain, opts = {})
+      delete_domain_with_http_info(domain, opts)
       nil
     end
 
@@ -34,13 +102,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_delete_with_http_info(domain, opts = {})
+    def delete_domain_with_http_info(domain, 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.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_delete"
+        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))
@@ -66,7 +134,7 @@ module Lockally
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_delete",
+        :operation => :"DomainsApi.delete_domain",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -77,7 +145,133 @@ 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_delete\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
+
+    # Turn off the custom Return-Path
+    # API mail uses the sender's own address as the envelope sender again, from the next message. 
+    # @param domain [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [nil]
+    def disable_return_path(domain, opts = {})
+      disable_return_path_with_http_info(domain, opts)
+      nil
+    end
+
+    # Turn off the custom Return-Path
+    # API mail uses the sender&#39;s own address as the envelope sender again, from the next message. 
+    # @param domain [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(nil, Integer, Hash)>] nil, response status code and response headers
+    def disable_return_path_with_http_info(domain, opts = {})
+      if @api_client.config.debugging
+        @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.disable_return_path"
+      end
+      # resource path
+      local_var_path = '/v1/domains/{domain}/return-path'.sub('{domain}', CGI.escape(domain.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # 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']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type]
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['bearerAuth']
+
+      new_options = opts.merge(
+        :operation => :"DomainsApi.disable_return_path",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      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#disable_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. 
+    # @param domain [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [ReturnPath]
+    def enable_return_path(domain, opts = {})
+      data, _status_code, _headers = enable_return_path_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. 
+    # @param domain [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(ReturnPath, Integer, Hash)>] ReturnPath data, response status code and response headers
+    def enable_return_path_with_http_info(domain, opts = {})
+      if @api_client.config.debugging
+        @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.enable_return_path"
+      end
+      # resource path
+      local_var_path = '/v1/domains/{domain}/return-path'.sub('{domain}', CGI.escape(domain.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # 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']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ReturnPath'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['bearerAuth']
+
+      new_options = opts.merge(
+        :operation => :"DomainsApi.enable_return_path",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      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#enable_return_path\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -86,8 +280,8 @@ module Lockally
     # @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)
+    def get_domain(domain, opts = {})
+      data, _status_code, _headers = get_domain_with_http_info(domain, opts)
       data
     end
 
@@ -95,13 +289,13 @@ module Lockally
     # @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 = {})
+    def get_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.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_get"
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.get_domain"
       end
       # resource path
       local_var_path = '/v1/domains/{domain}'.sub('{domain}', CGI.escape(domain.to_s))
@@ -127,7 +321,7 @@ module Lockally
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_domain_get",
+        :operation => :"DomainsApi.get_domain",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -138,36 +332,36 @@ module Lockally
 
       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_get\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
 
-    # 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. 
+    # 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 [Domain]
-    def v1_domains_domain_verify_post(domain, opts = {})
-      data, _status_code, _headers = v1_domains_domain_verify_post_with_http_info(domain, opts)
+    # @return [ReturnPath]
+    def get_return_path(domain, opts = {})
+      data, _status_code, _headers = get_return_path_with_http_info(domain, 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. 
+    # 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<(Domain, Integer, Hash)>] Domain data, response status code and response headers
-    def v1_domains_domain_verify_post_with_http_info(domain, opts = {})
+    # @return [Array<(ReturnPath, Integer, Hash)>] ReturnPath data, response status code and response headers
+    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_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_verify_post"
+        fail ArgumentError, "Missing the required parameter 'domain' when calling DomainsApi.get_return_path"
       end
       # resource path
-      local_var_path = '/v1/domains/{domain}/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] || {}
@@ -184,13 +378,13 @@ module Lockally
       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_domain_verify_post",
+        :operation => :"DomainsApi.get_return_path",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -199,9 +393,9 @@ 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#get_return_path\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -209,19 +403,19 @@ module Lockally
     # List domains
     # Returns every domain registered under the calling tenant.
     # @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 [ListDomains200Response]
+    def list_domains(opts = {})
+      data, _status_code, _headers = list_domains_with_http_info(opts)
       data
     end
 
     # List domains
     # Returns every domain registered under the calling tenant.
     # @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<(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_get ...'
+        @api_client.config.logger.debug 'Calling API: DomainsApi.list_domains ...'
       end
       # resource path
       local_var_path = '/v1/domains'
@@ -241,13 +435,13 @@ module Lockally
       post_body = opts[:debug_body]
 
       # return_type
-      return_type = opts[:debug_return_type] || 'V1DomainsGet200Response'
+      return_type = opts[:debug_return_type] || 'ListDomains200Response'
 
       # auth_names
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_get",
+        :operation => :"DomainsApi.list_domains",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -258,36 +452,36 @@ module Lockally
 
       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_get\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
 
-    # 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] 
+    # 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 [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)
+    def verify_domain(domain, opts = {})
+      data, _status_code, _headers = verify_domain_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] 
+    # 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<(Domain, Integer, Hash)>] Domain data, response status code and response headers
-    def v1_domains_post_with_http_info(v1_domains_post_request, opts = {})
+    def verify_domain_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_domain ...'
       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_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] || {}
@@ -296,17 +490,12 @@ 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'
@@ -315,7 +504,70 @@ module Lockally
       auth_names = opts[:debug_auth_names] || ['bearerAuth']
 
       new_options = opts.merge(
-        :operation => :"DomainsApi.v1_domains_post",
+        :operation => :"DomainsApi.verify_domain",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      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#verify_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. 
+    # @param domain [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [ReturnPath]
+    def verify_return_path(domain, opts = {})
+      data, _status_code, _headers = verify_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. 
+    # @param domain [String] 
+    # @param [Hash] opts the optional parameters
+    # @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.verify_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.verify_return_path"
+      end
+      # resource path
+      local_var_path = '/v1/domains/{domain}/return-path/verify'.sub('{domain}', CGI.escape(domain.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # 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']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ReturnPath'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['bearerAuth']
+
+      new_options = opts.merge(
+        :operation => :"DomainsApi.verify_return_path",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -326,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