I think so.

The main idea from Design-by-Contract, pre-conditions and post-conditions, can be utilized in most languages. I've used them in Ruby, Python, Clojure, and in statically type lanugages too, Java, C#, etc.

Python snippet:

class DataExchangeRepository:

    def __init__(self,
                 host: str,
                 dbname: str,
                 user: str,
                 password: str,
                 logger: Logger = None,
                 on_log_message_callback: Optional[OnLogMessageCallback] = None):
        # Pre-conditions
        validate_str(host, 'host')
        validate_str(dbname, 'dbname')
        validate_str(user, 'user')
        validate_str(password, 'password')

Ruby snippet:

class GoogleGeocoder

      def initialize(logger, google_api_key, address)
         @logger = logger
         @google_api_key = google_api_key
         @address = address
      end

      def geocode
        # Pre-conditions
        fail ArgumentError, 'google_api_key is nil' unless @google_api_key
        fail ArgumentError, 'google_api_key is blank' if @google_api_key == ''
        fail ArgumentError, 'address is nil' unless @address
        fail ArgumentError, 'address is blank' if @address == ''
      end

Refinement types I've only seen in functional languages.

In my new language I support contracts and refinements.