czmq-ffi-gen 0.9.2-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9e567bcf0127db1f20397629afd8c4deebc8e3ae
+  data.tar.gz: c9070bf490bfd345527d5c4a9563ca79dac763ed
+SHA512:
+  metadata.gz: 220ceff47ba7d0622903fb10effc5efc3f26a0d861fbc12857629d44ee6f09afe83b5fc5e6d0b84199a149547d1080e1da3be1b57e81db51900abf1280a44d23
+  data.tar.gz: ad0cc09050221ddc52f1b9190f37d1b59831f9f5a877a0bb45244d59f4dd26fbe96d5d05f266eadadbc7cd70b085636561be81d1990601c9d0a9a71cf10487d6

data/AUTHORS

@@ -0,0 +1 @@
+Patrik Wenger <paddor@gmail.com>

data/CHANGES.md

@@ -0,0 +1,92 @@
+0.9.2 (09/19/2016)
+-----
+* no changes
+
+0.9.1 (09/19/2016)
+-----
+* no changes, just second try at publishing (publishing of version 0.9.0 failed
+  due to human error)
+
+0.9.0 (09/18/2016)
+-----
+* support building and pushing fat gems for Windows x86 and x64
+* upgrade CZMQ low-level binding to fix cross compile errors
+
+0.8.3 (03/29/2016)
+-----
+* avoid extra call to wrapper method CZMQ::FFI::Errors.errno (CZTop's test
+  suite doesn't like this)
+
+0.8.2 (03/29/2016)
+-----
+* fix CZMQ::FFI::Errors.strerror
+
+0.8.1 (03/29/2016)
+-----
+* provide CZMQ::FFI::ZMQ_VERSION
+* rename CZMQ::FFI::LIBRARY_VERSION to CZMQ::FFI::CZMQ_VERSION
+* new module CZMQ::FFI::LibZMQ which is the sole place to interact directly
+  with the ZMQ library
+
+0.8.0 (03/27/2016)
+-----
+* upgrade CZMQ low-level binding to
+  - fix function names in warnings
+  - have constants instead of enums
+  - adapt to the new interface of zarmour_encode/decode
+
+0.7.0 (01/21/2016)
+-----
+* add support for current stable release 3.0.2 of CZMQ
+* upgrade CZMQ low-level binding to
+  - gracefully handle absent draft functions
+
+0.6.0 (01/15/2016)
+-----
+* upgrade CZMQ low-level binding to
+  - add support for ZMTP 3.1 heartbeat options
+
+0.5.0 (01/14/2016)
+-----
+* add CZMQ::FFI::Errors
+  - hand-written code to interact with libzmq
+  - .errno returns error code of last (ZMQ) error
+  - .strerror returns string representation of last (ZMQ) error
+* upgrade CZMQ low-level binding to
+  - add Zchunk
+
+0.4.1 (01/06/2016)
+-----
+* upgrade CZMQ low-level binding to
+  - fix zbeacon so it doesn't close STDIN
+
+0.4.0 (12/26/2015)
+-----
+* upgrade CZMQ low-level binding to
+  - add Zproc.has_curve
+* add basic specs for Zproc
+
+0.3.0 (12/15/2015)
+-----
+* upgrade CZMQ low-level binding to
+  - add Zcert#unset_meta
+
+0.2.1 (12/12/2015)
+-----
+* upgrade CZMQ low-level binding to
+  - allow passing a null pointer (nil) for an FFI :string parameter
+
+0.2.0 (12/10/2015)
+-----
+* using new CZMQ version which
+  - fixes some security issues
+  - adds Zcert and Zcertstore
+* basic specs for each Zclass added
+
+0.1.1 (12/09/2015)
+-----
+* include some auxiliary files like CHANGES.md, LICENSE, and README.md into gem
+
+0.1.0 (12/09/2015)
+-----
+* Initial release

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2016, Patrik Wenger
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+

data/README.md

@@ -0,0 +1,112 @@
+[![Build Status on Travis CI](https://travis-ci.org/paddor/czmq-ffi-gen.svg?branch=master)](https://travis-ci.org/paddor/czmq-ffi-gen?branch=master)
+[![Dependency Status](https://gemnasium.com/paddor/czmq-ffi-gen.svg)](https://gemnasium.com/paddor/czmq-ffi-gen)
+
+# Generated CZMQ::FFI
+
+This repository is used to package and release the Ruby gem _czmq-ffi-gen_, the
+low-level Ruby FFI binding for [CZMQ](https://github.com/zeromq/czmq).  The gem
+_czmq-ffi-gen_ can be used as a base for a higher-level CZMQ binding like
+[CZTop](https://github.com/paddor/cztop). But of course you can use it for
+anything you want. :-)
+
+## Caveats
+
+### Not Ruby-like
+This is generated code. It is generated from the API models in CZMQ using
+[zproject](https://github.com/zeromq/zproject). It doesn't feel like Ruby. It's
+not intended to be used directly. Instead, use
+[CZTop](https://github.com/paddor/cztop), or write your own wrapper for this
+library.
+
+### Generated code isn't actually in this repository
+The actual generated code lies in CZMQ, which is Git submodule of this
+repository, registered under `vendor/czmq`.
+
+So if you're not happy with any of the generated code, go have a closer look at
+[CZMQ](https://github.com/zeromq/czmq) (or
+[zproject](https://github.com/zeromq/zproject), which is used by CZMQ to
+generate the low-level binding).
+
+### API Documentation
+For that same reason, API documentation of unreleased code (directly off this
+repository), like
+[rubydoc.info/github/paddor/czmq-ffi-gen](http://www.rubydoc.info/github/paddor/czmq-ffi-gen)
+**does NOT include any of the generated code**. _Rubydoc.info_ doesn't check
+out Git submodules as part of its documentation procedure.
+
+However, the API documentation of the **released** gem should include all the
+code, as the gem release process will include all required source files
+directly within the gem.
+
+Check out
+[http://www.rubydoc.info/gems/czmq-ffi-gen](http://www.rubydoc.info/gems/czmq-ffi-gen)
+for the API documentation **for the released gem**.
+
+## Requirements
+
+* CZMQ > 3.0 (you **need to** build from master)
+* ZMQ >= 4.0
+
+For security mechanisms like CURVE, you'll need:
+* [libsodium](https://github.com/jedisct1/libsodium)<Paste>
+
+On OSX using homebrew, run:
+
+    $ brew install libsodium
+    $ brew install zmq --with-libsodium
+    $ brew install czmq --HEAD
+
+If you're running Linux, go check [this page](http://zeromq.org/distro:_start)
+to get more help. Make sure to install CZMQ, not only ZMQ.
+
+**Note**: The option `--HEAD` is required because this binding is generated
+directly from CZMQ's master branch. The current and older releases aren't supported.
+
+### Supported Rubies
+
+See [.travis.yml](https://github.com/paddor/czmq-ffi-gen/blob/master/.travis.yml)
+for a list of Ruby versions against which czmq-ffi-gen is tested.
+
+At the time of writing, these include:
+
+* MRI 2.3, 2.2.4, 2.1.8
+* Rubinius (HEAD)
+* JRuby 9000 (HEAD)
+
+#### Known NOT to work
+
+* JRuby 1.7.x and MRI < 2.0
+  * doesn't work because of the use of the double splat operator (`**opts`)
+
+## Installation
+
+To use this gem, add this line to your application's Gemfile:
+
+```ruby
+gem 'czmq-ffi-gen'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install czmq-ffi-gen
+
+## Usage
+
+Check out [CZTop](https://github.com/paddor/cztop) or the API documentation to
+see how this project can be used. :-)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake spec` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+## License
+
+The gem is available as open source under the terms of the [ISC
+License](http://opensource.org/licenses/ISC).  See the
+[LICENSE](https://github.com/paddor/cztop/blob/master/LICENSE) file.

data/lib/czmq-ffi-gen.rb

@@ -0,0 +1,7 @@
+require_relative "czmq-ffi-gen/vendor"
+require_relative "czmq-ffi-gen/czmq/ffi"
+require_relative "czmq-ffi-gen/versions"
+require_relative "czmq-ffi-gen/errors"
+require_relative "czmq-ffi-gen/signals"
+require_relative "czmq-ffi-gen/legacy"
+CZMQ::FFI.available? or raise LoadError, "libczmq is not available"

data/lib/czmq-ffi-gen/czmq/ffi.rb

@@ -0,0 +1,1210 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+
+require 'ffi'
+require_relative 'ffi/version'
+
+module CZMQ
+  module FFI
+    module LibC
+      extend ::FFI::Library
+      ffi_lib ::FFI::Platform::LIBC
+      attach_function :free, [ :pointer ], :void, blocking: true
+    end
+
+    extend ::FFI::Library
+
+    def self.available?
+      @available
+    end
+
+    begin
+      lib_name = 'libczmq'
+      lib_paths = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
+        .map { |path| "#{path}/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}" }
+      ffi_lib lib_paths + [lib_name]
+      @available = true
+    rescue LoadError
+      warn ""
+      warn "WARNING: ::CZMQ::FFI is not available without libczmq."
+      warn ""
+      @available = false
+    end
+
+    if available?
+      opts = {
+        blocking: true  # only necessary on MRI to deal with the GIL.
+      }
+
+      attach_function :zactor_new, [:pointer, :pointer], :pointer, **opts
+      attach_function :zactor_destroy, [:pointer], :void, **opts
+      attach_function :zactor_send, [:pointer, :pointer], :int, **opts
+      attach_function :zactor_recv, [:pointer], :pointer, **opts
+      attach_function :zactor_is, [:pointer], :bool, **opts
+      attach_function :zactor_resolve, [:pointer], :pointer, **opts
+      attach_function :zactor_sock, [:pointer], :pointer, **opts
+      attach_function :zactor_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zactor'
+
+      attach_function :zarmour_new, [], :pointer, **opts
+      attach_function :zarmour_destroy, [:pointer], :void, **opts
+      attach_function :zarmour_encode, [:pointer, :pointer, :size_t], :pointer, **opts
+      attach_function :zarmour_decode, [:pointer, :string], :pointer, **opts
+      attach_function :zarmour_mode, [:pointer], :int, **opts
+      attach_function :zarmour_mode_str, [:pointer], :string, **opts
+      attach_function :zarmour_set_mode, [:pointer, :int], :void, **opts
+      attach_function :zarmour_pad, [:pointer], :bool, **opts
+      attach_function :zarmour_set_pad, [:pointer, :bool], :void, **opts
+      attach_function :zarmour_pad_char, [:pointer], :pointer, **opts
+      attach_function :zarmour_set_pad_char, [:pointer, :pointer], :void, **opts
+      attach_function :zarmour_line_breaks, [:pointer], :bool, **opts
+      attach_function :zarmour_set_line_breaks, [:pointer, :bool], :void, **opts
+      attach_function :zarmour_line_length, [:pointer], :size_t, **opts
+      attach_function :zarmour_set_line_length, [:pointer, :size_t], :void, **opts
+      attach_function :zarmour_print, [:pointer], :void, **opts
+      attach_function :zarmour_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zarmour'
+
+      attach_function :zcert_new, [], :pointer, **opts
+      attach_function :zcert_new_from, [:pointer, :pointer], :pointer, **opts
+      attach_function :zcert_load, [:string], :pointer, **opts
+      attach_function :zcert_destroy, [:pointer], :void, **opts
+      attach_function :zcert_public_key, [:pointer], :pointer, **opts
+      attach_function :zcert_secret_key, [:pointer], :pointer, **opts
+      attach_function :zcert_public_txt, [:pointer], :string, **opts
+      attach_function :zcert_secret_txt, [:pointer], :string, **opts
+      attach_function :zcert_set_meta, [:pointer, :string, :string, :varargs], :void, **opts
+      begin # DRAFT method
+        attach_function :zcert_unset_meta, [:pointer, :string], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zcert_unset_meta() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zcert_meta, [:pointer, :string], :string, **opts
+      attach_function :zcert_meta_keys, [:pointer], :pointer, **opts
+      attach_function :zcert_save, [:pointer, :string], :int, **opts
+      attach_function :zcert_save_public, [:pointer, :string], :int, **opts
+      attach_function :zcert_save_secret, [:pointer, :string], :int, **opts
+      attach_function :zcert_apply, [:pointer, :pointer], :void, **opts
+      attach_function :zcert_dup, [:pointer], :pointer, **opts
+      attach_function :zcert_eq, [:pointer, :pointer], :bool, **opts
+      attach_function :zcert_print, [:pointer], :void, **opts
+      attach_function :zcert_fprint, [:pointer, :pointer], :void, **opts
+      attach_function :zcert_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zcert'
+
+      attach_function :zcertstore_new, [:string], :pointer, **opts
+      attach_function :zcertstore_destroy, [:pointer], :void, **opts
+      begin # DRAFT method
+        attach_function :zcertstore_set_loader, [:pointer, :pointer, :pointer, :pointer], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zcertstore_set_loader() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zcertstore_lookup, [:pointer, :string], :pointer, **opts
+      attach_function :zcertstore_insert, [:pointer, :pointer], :void, **opts
+      begin # DRAFT method
+        attach_function :zcertstore_empty, [:pointer], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zcertstore_empty() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zcertstore_print, [:pointer], :void, **opts
+      attach_function :zcertstore_fprint, [:pointer, :pointer], :void, **opts
+      attach_function :zcertstore_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zcertstore'
+
+      attach_function :zchunk_new, [:pointer, :size_t], :pointer, **opts
+      attach_function :zchunk_destroy, [:pointer], :void, **opts
+      attach_function :zchunk_resize, [:pointer, :size_t], :void, **opts
+      attach_function :zchunk_size, [:pointer], :size_t, **opts
+      attach_function :zchunk_max_size, [:pointer], :size_t, **opts
+      attach_function :zchunk_data, [:pointer], :pointer, **opts
+      attach_function :zchunk_set, [:pointer, :pointer, :size_t], :size_t, **opts
+      attach_function :zchunk_fill, [:pointer, :char, :size_t], :size_t, **opts
+      attach_function :zchunk_append, [:pointer, :pointer, :size_t], :size_t, **opts
+      attach_function :zchunk_extend, [:pointer, :pointer, :size_t], :size_t, **opts
+      attach_function :zchunk_consume, [:pointer, :pointer], :size_t, **opts
+      attach_function :zchunk_exhausted, [:pointer], :bool, **opts
+      attach_function :zchunk_read, [:pointer, :size_t], :pointer, **opts
+      attach_function :zchunk_write, [:pointer, :pointer], :int, **opts
+      attach_function :zchunk_slurp, [:string, :size_t], :pointer, **opts
+      attach_function :zchunk_dup, [:pointer], :pointer, **opts
+      attach_function :zchunk_strhex, [:pointer], :pointer, **opts
+      attach_function :zchunk_strdup, [:pointer], :pointer, **opts
+      attach_function :zchunk_streq, [:pointer, :string], :bool, **opts
+      attach_function :zchunk_pack, [:pointer], :pointer, **opts
+      attach_function :zchunk_unpack, [:pointer], :pointer, **opts
+      attach_function :zchunk_digest, [:pointer], :string, **opts
+      attach_function :zchunk_fprint, [:pointer, :pointer], :void, **opts
+      attach_function :zchunk_print, [:pointer], :void, **opts
+      attach_function :zchunk_is, [:pointer], :bool, **opts
+      attach_function :zchunk_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zchunk'
+
+      attach_function :zclock_sleep, [:int], :void, **opts
+      attach_function :zclock_time, [], :pointer, **opts
+      attach_function :zclock_mono, [], :pointer, **opts
+      attach_function :zclock_usecs, [], :pointer, **opts
+      attach_function :zclock_timestr, [], :pointer, **opts
+      attach_function :zclock_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zclock'
+
+      attach_function :zconfig_new, [:string, :pointer], :pointer, **opts
+      attach_function :zconfig_load, [:string], :pointer, **opts
+      attach_function :zconfig_loadf, [:string, :varargs], :pointer, **opts
+      attach_function :zconfig_destroy, [:pointer], :void, **opts
+      attach_function :zconfig_name, [:pointer], :pointer, **opts
+      attach_function :zconfig_value, [:pointer], :pointer, **opts
+      attach_function :zconfig_put, [:pointer, :string, :string], :void, **opts
+      attach_function :zconfig_putf, [:pointer, :string, :string, :varargs], :void, **opts
+      attach_function :zconfig_get, [:pointer, :string, :string], :pointer, **opts
+      attach_function :zconfig_set_name, [:pointer, :string], :void, **opts
+      attach_function :zconfig_set_value, [:pointer, :string, :varargs], :void, **opts
+      attach_function :zconfig_child, [:pointer], :pointer, **opts
+      attach_function :zconfig_next, [:pointer], :pointer, **opts
+      attach_function :zconfig_locate, [:pointer, :string], :pointer, **opts
+      attach_function :zconfig_at_depth, [:pointer, :int], :pointer, **opts
+      attach_function :zconfig_execute, [:pointer, :pointer, :pointer], :int, **opts
+      attach_function :zconfig_set_comment, [:pointer, :string, :varargs], :void, **opts
+      attach_function :zconfig_comments, [:pointer], :pointer, **opts
+      attach_function :zconfig_save, [:pointer, :string], :int, **opts
+      attach_function :zconfig_savef, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zconfig_filename, [:pointer], :string, **opts
+      attach_function :zconfig_reload, [:pointer], :int, **opts
+      attach_function :zconfig_chunk_load, [:pointer], :pointer, **opts
+      attach_function :zconfig_chunk_save, [:pointer], :pointer, **opts
+      attach_function :zconfig_str_load, [:string], :pointer, **opts
+      attach_function :zconfig_str_save, [:pointer], :pointer, **opts
+      attach_function :zconfig_has_changed, [:pointer], :bool, **opts
+      attach_function :zconfig_fprint, [:pointer, :pointer], :void, **opts
+      attach_function :zconfig_print, [:pointer], :void, **opts
+      attach_function :zconfig_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zconfig'
+
+      attach_function :zdigest_new, [], :pointer, **opts
+      attach_function :zdigest_destroy, [:pointer], :void, **opts
+      attach_function :zdigest_update, [:pointer, :pointer, :size_t], :void, **opts
+      attach_function :zdigest_data, [:pointer], :pointer, **opts
+      attach_function :zdigest_size, [:pointer], :size_t, **opts
+      attach_function :zdigest_string, [:pointer], :pointer, **opts
+      attach_function :zdigest_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zdigest'
+
+      attach_function :zdir_new, [:string, :string], :pointer, **opts
+      attach_function :zdir_destroy, [:pointer], :void, **opts
+      attach_function :zdir_path, [:pointer], :string, **opts
+      attach_function :zdir_modified, [:pointer], :pointer, **opts
+      attach_function :zdir_cursize, [:pointer], :pointer, **opts
+      attach_function :zdir_count, [:pointer], :size_t, **opts
+      attach_function :zdir_list, [:pointer], :pointer, **opts
+      attach_function :zdir_remove, [:pointer, :bool], :void, **opts
+      attach_function :zdir_diff, [:pointer, :pointer, :string], :pointer, **opts
+      attach_function :zdir_resync, [:pointer, :string], :pointer, **opts
+      attach_function :zdir_cache, [:pointer], :pointer, **opts
+      attach_function :zdir_fprint, [:pointer, :pointer, :int], :void, **opts
+      attach_function :zdir_print, [:pointer, :int], :void, **opts
+      attach_function :zdir_watch, [:pointer, :pointer], :void, **opts
+      attach_function :zdir_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zdir'
+
+      attach_function :zdir_patch_new, [:string, :pointer, :int, :string], :pointer, **opts
+      attach_function :zdir_patch_destroy, [:pointer], :void, **opts
+      attach_function :zdir_patch_dup, [:pointer], :pointer, **opts
+      attach_function :zdir_patch_path, [:pointer], :string, **opts
+      attach_function :zdir_patch_file, [:pointer], :pointer, **opts
+      attach_function :zdir_patch_op, [:pointer], :int, **opts
+      attach_function :zdir_patch_vpath, [:pointer], :string, **opts
+      attach_function :zdir_patch_digest_set, [:pointer], :void, **opts
+      attach_function :zdir_patch_digest, [:pointer], :string, **opts
+      attach_function :zdir_patch_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zdir_patch'
+
+      attach_function :zfile_new, [:string, :string], :pointer, **opts
+      attach_function :zfile_destroy, [:pointer], :void, **opts
+      attach_function :zfile_dup, [:pointer], :pointer, **opts
+      attach_function :zfile_filename, [:pointer, :string], :string, **opts
+      attach_function :zfile_restat, [:pointer], :void, **opts
+      attach_function :zfile_modified, [:pointer], :pointer, **opts
+      attach_function :zfile_cursize, [:pointer], :pointer, **opts
+      attach_function :zfile_is_directory, [:pointer], :bool, **opts
+      attach_function :zfile_is_regular, [:pointer], :bool, **opts
+      attach_function :zfile_is_readable, [:pointer], :bool, **opts
+      attach_function :zfile_is_writeable, [:pointer], :bool, **opts
+      attach_function :zfile_is_stable, [:pointer], :bool, **opts
+      attach_function :zfile_has_changed, [:pointer], :bool, **opts
+      attach_function :zfile_remove, [:pointer], :void, **opts
+      attach_function :zfile_input, [:pointer], :int, **opts
+      attach_function :zfile_output, [:pointer], :int, **opts
+      attach_function :zfile_read, [:pointer, :size_t, :pointer], :pointer, **opts
+      attach_function :zfile_eof, [:pointer], :bool, **opts
+      attach_function :zfile_write, [:pointer, :pointer, :pointer], :int, **opts
+      attach_function :zfile_readln, [:pointer], :string, **opts
+      attach_function :zfile_close, [:pointer], :void, **opts
+      attach_function :zfile_handle, [:pointer], :pointer, **opts
+      attach_function :zfile_digest, [:pointer], :string, **opts
+      attach_function :zfile_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zfile'
+
+      attach_function :zframe_new, [:pointer, :size_t], :pointer, **opts
+      attach_function :zframe_new_empty, [], :pointer, **opts
+      attach_function :zframe_from, [:string], :pointer, **opts
+      attach_function :zframe_recv, [:pointer], :pointer, **opts
+      attach_function :zframe_destroy, [:pointer], :void, **opts
+      attach_function :zframe_send, [:pointer, :pointer, :int], :int, **opts
+      attach_function :zframe_size, [:pointer], :size_t, **opts
+      attach_function :zframe_data, [:pointer], :pointer, **opts
+      attach_function :zframe_meta, [:pointer, :string], :string, **opts
+      attach_function :zframe_dup, [:pointer], :pointer, **opts
+      attach_function :zframe_strhex, [:pointer], :pointer, **opts
+      attach_function :zframe_strdup, [:pointer], :pointer, **opts
+      attach_function :zframe_streq, [:pointer, :string], :bool, **opts
+      attach_function :zframe_more, [:pointer], :int, **opts
+      attach_function :zframe_set_more, [:pointer, :int], :void, **opts
+      begin # DRAFT method
+        attach_function :zframe_routing_id, [:pointer], :uint32, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zframe_routing_id() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zframe_set_routing_id, [:pointer, :uint32], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zframe_set_routing_id() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zframe_group, [:pointer], :string, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zframe_group() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zframe_set_group, [:pointer, :string], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zframe_set_group() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zframe_eq, [:pointer, :pointer], :bool, **opts
+      attach_function :zframe_reset, [:pointer, :pointer, :size_t], :void, **opts
+      attach_function :zframe_print, [:pointer, :string], :void, **opts
+      attach_function :zframe_is, [:pointer], :bool, **opts
+      attach_function :zframe_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zframe'
+
+      attach_function :zhash_new, [], :pointer, **opts
+      attach_function :zhash_unpack, [:pointer], :pointer, **opts
+      attach_function :zhash_destroy, [:pointer], :void, **opts
+      attach_function :zhash_insert, [:pointer, :string, :pointer], :int, **opts
+      attach_function :zhash_update, [:pointer, :string, :pointer], :void, **opts
+      attach_function :zhash_delete, [:pointer, :string], :void, **opts
+      attach_function :zhash_lookup, [:pointer, :string], :pointer, **opts
+      attach_function :zhash_rename, [:pointer, :string, :string], :int, **opts
+      attach_function :zhash_freefn, [:pointer, :string, :pointer], :pointer, **opts
+      attach_function :zhash_size, [:pointer], :size_t, **opts
+      attach_function :zhash_dup, [:pointer], :pointer, **opts
+      attach_function :zhash_keys, [:pointer], :pointer, **opts
+      attach_function :zhash_first, [:pointer], :pointer, **opts
+      attach_function :zhash_next, [:pointer], :pointer, **opts
+      attach_function :zhash_cursor, [:pointer], :string, **opts
+      attach_function :zhash_comment, [:pointer, :string, :varargs], :void, **opts
+      attach_function :zhash_pack, [:pointer], :pointer, **opts
+      attach_function :zhash_save, [:pointer, :string], :int, **opts
+      attach_function :zhash_load, [:pointer, :string], :int, **opts
+      attach_function :zhash_refresh, [:pointer], :int, **opts
+      attach_function :zhash_autofree, [:pointer], :void, **opts
+      attach_function :zhash_foreach, [:pointer, :pointer, :pointer], :int, **opts
+      attach_function :zhash_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zhash'
+
+      attach_function :zhashx_new, [], :pointer, **opts
+      attach_function :zhashx_unpack, [:pointer], :pointer, **opts
+      begin # DRAFT method
+        attach_function :zhashx_unpack_own, [:pointer, :pointer], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zhashx_unpack_own() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zhashx_destroy, [:pointer], :void, **opts
+      attach_function :zhashx_insert, [:pointer, :pointer, :pointer], :int, **opts
+      attach_function :zhashx_update, [:pointer, :pointer, :pointer], :void, **opts
+      attach_function :zhashx_delete, [:pointer, :pointer], :void, **opts
+      attach_function :zhashx_purge, [:pointer], :void, **opts
+      attach_function :zhashx_lookup, [:pointer, :pointer], :pointer, **opts
+      attach_function :zhashx_rename, [:pointer, :pointer, :pointer], :int, **opts
+      attach_function :zhashx_freefn, [:pointer, :pointer, :pointer], :pointer, **opts
+      attach_function :zhashx_size, [:pointer], :size_t, **opts
+      attach_function :zhashx_keys, [:pointer], :pointer, **opts
+      attach_function :zhashx_values, [:pointer], :pointer, **opts
+      attach_function :zhashx_first, [:pointer], :pointer, **opts
+      attach_function :zhashx_next, [:pointer], :pointer, **opts
+      attach_function :zhashx_cursor, [:pointer], :pointer, **opts
+      attach_function :zhashx_comment, [:pointer, :string, :varargs], :void, **opts
+      attach_function :zhashx_save, [:pointer, :string], :int, **opts
+      attach_function :zhashx_load, [:pointer, :string], :int, **opts
+      attach_function :zhashx_refresh, [:pointer], :int, **opts
+      attach_function :zhashx_pack, [:pointer], :pointer, **opts
+      begin # DRAFT method
+        attach_function :zhashx_pack_own, [:pointer, :pointer], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zhashx_pack_own() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zhashx_dup, [:pointer], :pointer, **opts
+      attach_function :zhashx_set_destructor, [:pointer, :pointer], :void, **opts
+      attach_function :zhashx_set_duplicator, [:pointer, :pointer], :void, **opts
+      attach_function :zhashx_set_key_destructor, [:pointer, :pointer], :void, **opts
+      attach_function :zhashx_set_key_duplicator, [:pointer, :pointer], :void, **opts
+      attach_function :zhashx_set_key_comparator, [:pointer, :pointer], :void, **opts
+      attach_function :zhashx_set_key_hasher, [:pointer, :pointer], :void, **opts
+      attach_function :zhashx_dup_v2, [:pointer], :pointer, **opts
+      attach_function :zhashx_autofree, [:pointer], :void, **opts
+      attach_function :zhashx_foreach, [:pointer, :pointer, :pointer], :int, **opts
+      attach_function :zhashx_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zhashx'
+
+      attach_function :ziflist_new, [], :pointer, **opts
+      attach_function :ziflist_destroy, [:pointer], :void, **opts
+      attach_function :ziflist_reload, [:pointer], :void, **opts
+      attach_function :ziflist_size, [:pointer], :size_t, **opts
+      attach_function :ziflist_first, [:pointer], :string, **opts
+      attach_function :ziflist_next, [:pointer], :string, **opts
+      attach_function :ziflist_address, [:pointer], :string, **opts
+      attach_function :ziflist_broadcast, [:pointer], :string, **opts
+      attach_function :ziflist_netmask, [:pointer], :string, **opts
+      attach_function :ziflist_print, [:pointer], :void, **opts
+      attach_function :ziflist_test, [:bool], :void, **opts
+
+      require_relative 'ffi/ziflist'
+
+      attach_function :zlist_new, [], :pointer, **opts
+      attach_function :zlist_destroy, [:pointer], :void, **opts
+      attach_function :zlist_first, [:pointer], :pointer, **opts
+      attach_function :zlist_next, [:pointer], :pointer, **opts
+      attach_function :zlist_last, [:pointer], :pointer, **opts
+      attach_function :zlist_head, [:pointer], :pointer, **opts
+      attach_function :zlist_tail, [:pointer], :pointer, **opts
+      attach_function :zlist_item, [:pointer], :pointer, **opts
+      attach_function :zlist_append, [:pointer, :pointer], :int, **opts
+      attach_function :zlist_push, [:pointer, :pointer], :int, **opts
+      attach_function :zlist_pop, [:pointer], :pointer, **opts
+      attach_function :zlist_exists, [:pointer, :pointer], :bool, **opts
+      attach_function :zlist_remove, [:pointer, :pointer], :void, **opts
+      attach_function :zlist_dup, [:pointer], :pointer, **opts
+      attach_function :zlist_purge, [:pointer], :void, **opts
+      attach_function :zlist_size, [:pointer], :size_t, **opts
+      attach_function :zlist_sort, [:pointer, :pointer], :void, **opts
+      attach_function :zlist_autofree, [:pointer], :void, **opts
+      attach_function :zlist_comparefn, [:pointer, :pointer], :void, **opts
+      attach_function :zlist_freefn, [:pointer, :pointer, :pointer, :bool], :pointer, **opts
+      attach_function :zlist_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zlist'
+
+      attach_function :zlistx_new, [], :pointer, **opts
+      attach_function :zlistx_destroy, [:pointer], :void, **opts
+      attach_function :zlistx_add_start, [:pointer, :pointer], :pointer, **opts
+      attach_function :zlistx_add_end, [:pointer, :pointer], :pointer, **opts
+      attach_function :zlistx_size, [:pointer], :size_t, **opts
+      attach_function :zlistx_head, [:pointer], :pointer, **opts
+      attach_function :zlistx_tail, [:pointer], :pointer, **opts
+      attach_function :zlistx_first, [:pointer], :pointer, **opts
+      attach_function :zlistx_next, [:pointer], :pointer, **opts
+      attach_function :zlistx_prev, [:pointer], :pointer, **opts
+      attach_function :zlistx_last, [:pointer], :pointer, **opts
+      attach_function :zlistx_item, [:pointer], :pointer, **opts
+      attach_function :zlistx_cursor, [:pointer], :pointer, **opts
+      attach_function :zlistx_handle_item, [:pointer], :pointer, **opts
+      attach_function :zlistx_find, [:pointer, :pointer], :pointer, **opts
+      attach_function :zlistx_detach, [:pointer, :pointer], :pointer, **opts
+      attach_function :zlistx_detach_cur, [:pointer], :pointer, **opts
+      attach_function :zlistx_delete, [:pointer, :pointer], :int, **opts
+      attach_function :zlistx_move_start, [:pointer, :pointer], :void, **opts
+      attach_function :zlistx_move_end, [:pointer, :pointer], :void, **opts
+      attach_function :zlistx_purge, [:pointer], :void, **opts
+      attach_function :zlistx_sort, [:pointer], :void, **opts
+      attach_function :zlistx_insert, [:pointer, :pointer, :bool], :pointer, **opts
+      attach_function :zlistx_reorder, [:pointer, :pointer, :bool], :void, **opts
+      attach_function :zlistx_dup, [:pointer], :pointer, **opts
+      attach_function :zlistx_set_destructor, [:pointer, :pointer], :void, **opts
+      attach_function :zlistx_set_duplicator, [:pointer, :pointer], :void, **opts
+      attach_function :zlistx_set_comparator, [:pointer, :pointer], :void, **opts
+      attach_function :zlistx_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zlistx'
+
+      attach_function :zloop_new, [], :pointer, **opts
+      attach_function :zloop_destroy, [:pointer], :void, **opts
+      attach_function :zloop_reader, [:pointer, :pointer, :pointer, :pointer], :int, **opts
+      attach_function :zloop_reader_end, [:pointer, :pointer], :void, **opts
+      attach_function :zloop_reader_set_tolerant, [:pointer, :pointer], :void, **opts
+      attach_function :zloop_poller, [:pointer, :pointer, :pointer, :pointer], :int, **opts
+      attach_function :zloop_poller_end, [:pointer, :pointer], :void, **opts
+      attach_function :zloop_poller_set_tolerant, [:pointer, :pointer], :void, **opts
+      attach_function :zloop_timer, [:pointer, :size_t, :size_t, :pointer, :pointer], :int, **opts
+      attach_function :zloop_timer_end, [:pointer, :int], :int, **opts
+      attach_function :zloop_ticket, [:pointer, :pointer, :pointer], :pointer, **opts
+      attach_function :zloop_ticket_reset, [:pointer, :pointer], :void, **opts
+      attach_function :zloop_ticket_delete, [:pointer, :pointer], :void, **opts
+      attach_function :zloop_set_ticket_delay, [:pointer, :size_t], :void, **opts
+      attach_function :zloop_set_max_timers, [:pointer, :size_t], :void, **opts
+      attach_function :zloop_set_verbose, [:pointer, :bool], :void, **opts
+      begin # DRAFT method
+        attach_function :zloop_set_nonstop, [:pointer, :bool], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zloop_set_nonstop() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zloop_start, [:pointer], :int, **opts
+      attach_function :zloop_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zloop'
+
+      attach_function :zmsg_new, [], :pointer, **opts
+      attach_function :zmsg_recv, [:pointer], :pointer, **opts
+      attach_function :zmsg_load, [:pointer], :pointer, **opts
+      attach_function :zmsg_decode, [:pointer], :pointer, **opts
+      attach_function :zmsg_new_signal, [:char], :pointer, **opts
+      attach_function :zmsg_destroy, [:pointer], :void, **opts
+      attach_function :zmsg_send, [:pointer, :pointer], :int, **opts
+      attach_function :zmsg_sendm, [:pointer, :pointer], :int, **opts
+      attach_function :zmsg_size, [:pointer], :size_t, **opts
+      attach_function :zmsg_content_size, [:pointer], :size_t, **opts
+      begin # DRAFT method
+        attach_function :zmsg_routing_id, [:pointer], :uint32, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zmsg_routing_id() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zmsg_set_routing_id, [:pointer, :uint32], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zmsg_set_routing_id() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zmsg_prepend, [:pointer, :pointer], :int, **opts
+      attach_function :zmsg_append, [:pointer, :pointer], :int, **opts
+      attach_function :zmsg_pop, [:pointer], :pointer, **opts
+      attach_function :zmsg_pushmem, [:pointer, :pointer, :size_t], :int, **opts
+      attach_function :zmsg_addmem, [:pointer, :pointer, :size_t], :int, **opts
+      attach_function :zmsg_pushstr, [:pointer, :string], :int, **opts
+      attach_function :zmsg_addstr, [:pointer, :string], :int, **opts
+      attach_function :zmsg_pushstrf, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zmsg_addstrf, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zmsg_popstr, [:pointer], :pointer, **opts
+      attach_function :zmsg_addmsg, [:pointer, :pointer], :int, **opts
+      attach_function :zmsg_popmsg, [:pointer], :pointer, **opts
+      attach_function :zmsg_remove, [:pointer, :pointer], :void, **opts
+      attach_function :zmsg_first, [:pointer], :pointer, **opts
+      attach_function :zmsg_next, [:pointer], :pointer, **opts
+      attach_function :zmsg_last, [:pointer], :pointer, **opts
+      attach_function :zmsg_save, [:pointer, :pointer], :int, **opts
+      attach_function :zmsg_encode, [:pointer], :pointer, **opts
+      attach_function :zmsg_dup, [:pointer], :pointer, **opts
+      attach_function :zmsg_print, [:pointer], :void, **opts
+      attach_function :zmsg_eq, [:pointer, :pointer], :bool, **opts
+      attach_function :zmsg_signal, [:pointer], :int, **opts
+      attach_function :zmsg_is, [:pointer], :bool, **opts
+      attach_function :zmsg_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zmsg'
+
+      attach_function :zpoller_new, [:pointer, :varargs], :pointer, **opts
+      attach_function :zpoller_destroy, [:pointer], :void, **opts
+      attach_function :zpoller_add, [:pointer, :pointer], :int, **opts
+      attach_function :zpoller_remove, [:pointer, :pointer], :int, **opts
+      begin # DRAFT method
+        attach_function :zpoller_set_nonstop, [:pointer, :bool], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zpoller_set_nonstop() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zpoller_wait, [:pointer, :int], :pointer, **opts
+      attach_function :zpoller_expired, [:pointer], :bool, **opts
+      attach_function :zpoller_terminated, [:pointer], :bool, **opts
+      attach_function :zpoller_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zpoller'
+
+      begin # DRAFT method
+        attach_function :zproc_czmq_version, [], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_czmq_version() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_interrupted, [], :bool, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_interrupted() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_has_curve, [], :bool, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_has_curve() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_hostname, [], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_hostname() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_daemonize, [:string], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_daemonize() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_run_as, [:string, :string, :string], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_run_as() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_set_io_threads, [:size_t], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_set_io_threads() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_set_max_sockets, [:size_t], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_set_max_sockets() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_set_biface, [:string], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_set_biface() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_biface, [], :string, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_biface() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_set_log_ident, [:string], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_set_log_ident() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_set_log_sender, [:string], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_set_log_sender() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_set_log_system, [:bool], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_set_log_system() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_log_error, [:string, :varargs], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_log_error() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_log_warning, [:string, :varargs], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_log_warning() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_log_notice, [:string, :varargs], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_log_notice() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_log_info, [:string, :varargs], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_log_info() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_log_debug, [:string, :varargs], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_log_debug() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zproc_test, [:bool], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zproc_test() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+
+      require_relative 'ffi/zproc'
+
+      attach_function :zsock_new, [:int], :pointer, **opts
+      attach_function :zsock_new_pub, [:string], :pointer, **opts
+      attach_function :zsock_new_sub, [:string, :string], :pointer, **opts
+      attach_function :zsock_new_req, [:string], :pointer, **opts
+      attach_function :zsock_new_rep, [:string], :pointer, **opts
+      attach_function :zsock_new_dealer, [:string], :pointer, **opts
+      attach_function :zsock_new_router, [:string], :pointer, **opts
+      attach_function :zsock_new_push, [:string], :pointer, **opts
+      attach_function :zsock_new_pull, [:string], :pointer, **opts
+      attach_function :zsock_new_xpub, [:string], :pointer, **opts
+      attach_function :zsock_new_xsub, [:string], :pointer, **opts
+      attach_function :zsock_new_pair, [:string], :pointer, **opts
+      attach_function :zsock_new_stream, [:string], :pointer, **opts
+      begin # DRAFT method
+        attach_function :zsock_new_server, [:string], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_new_server() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_new_client, [:string], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_new_client() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_new_radio, [:string], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_new_radio() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_new_dish, [:string], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_new_dish() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_new_gather, [:string], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_new_gather() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_new_scatter, [:string], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_new_scatter() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zsock_destroy, [:pointer], :void, **opts
+      attach_function :zsock_bind, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zsock_endpoint, [:pointer], :string, **opts
+      attach_function :zsock_unbind, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zsock_connect, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zsock_disconnect, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zsock_attach, [:pointer, :string, :bool], :int, **opts
+      attach_function :zsock_type_str, [:pointer], :string, **opts
+      attach_function :zsock_send, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zsock_vsend, [:pointer, :string, :pointer], :int, **opts
+      attach_function :zsock_recv, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zsock_vrecv, [:pointer, :string, :pointer], :int, **opts
+      attach_function :zsock_bsend, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zsock_brecv, [:pointer, :string, :varargs], :int, **opts
+      begin # DRAFT method
+        attach_function :zsock_routing_id, [:pointer], :uint32, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_routing_id() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_set_routing_id, [:pointer, :uint32], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_set_routing_id() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zsock_set_unbounded, [:pointer], :void, **opts
+      attach_function :zsock_signal, [:pointer, :char], :int, **opts
+      attach_function :zsock_wait, [:pointer], :int, **opts
+      attach_function :zsock_flush, [:pointer], :void, **opts
+      begin # DRAFT method
+        attach_function :zsock_join, [:pointer, :string], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_join() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_leave, [:pointer, :string], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_leave() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zsock_is, [:pointer], :bool, **opts
+      attach_function :zsock_resolve, [:pointer], :pointer, **opts
+      begin # DRAFT method
+        attach_function :zsock_heartbeat_ivl, [:pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_heartbeat_ivl() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_set_heartbeat_ivl, [:pointer, :int], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_set_heartbeat_ivl() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_heartbeat_ttl, [:pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_heartbeat_ttl() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_set_heartbeat_ttl, [:pointer, :int], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_set_heartbeat_ttl() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_heartbeat_timeout, [:pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_heartbeat_timeout() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_set_heartbeat_timeout, [:pointer, :int], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_set_heartbeat_timeout() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_use_fd, [:pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_use_fd() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :zsock_set_use_fd, [:pointer, :int], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zsock_set_use_fd() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zsock_tos, [:pointer], :int, **opts
+      attach_function :zsock_set_tos, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_router_handover, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_router_mandatory, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_probe_router, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_req_relaxed, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_req_correlate, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_conflate, [:pointer, :int], :void, **opts
+      attach_function :zsock_zap_domain, [:pointer], :pointer, **opts
+      attach_function :zsock_set_zap_domain, [:pointer, :string], :void, **opts
+      attach_function :zsock_mechanism, [:pointer], :int, **opts
+      attach_function :zsock_plain_server, [:pointer], :int, **opts
+      attach_function :zsock_set_plain_server, [:pointer, :int], :void, **opts
+      attach_function :zsock_plain_username, [:pointer], :pointer, **opts
+      attach_function :zsock_set_plain_username, [:pointer, :string], :void, **opts
+      attach_function :zsock_plain_password, [:pointer], :pointer, **opts
+      attach_function :zsock_set_plain_password, [:pointer, :string], :void, **opts
+      attach_function :zsock_curve_server, [:pointer], :int, **opts
+      attach_function :zsock_set_curve_server, [:pointer, :int], :void, **opts
+      attach_function :zsock_curve_publickey, [:pointer], :pointer, **opts
+      attach_function :zsock_set_curve_publickey, [:pointer, :string], :void, **opts
+      attach_function :zsock_set_curve_publickey_bin, [:pointer, :pointer], :void, **opts
+      attach_function :zsock_curve_secretkey, [:pointer], :pointer, **opts
+      attach_function :zsock_set_curve_secretkey, [:pointer, :string], :void, **opts
+      attach_function :zsock_set_curve_secretkey_bin, [:pointer, :pointer], :void, **opts
+      attach_function :zsock_curve_serverkey, [:pointer], :pointer, **opts
+      attach_function :zsock_set_curve_serverkey, [:pointer, :string], :void, **opts
+      attach_function :zsock_set_curve_serverkey_bin, [:pointer, :pointer], :void, **opts
+      attach_function :zsock_gssapi_server, [:pointer], :int, **opts
+      attach_function :zsock_set_gssapi_server, [:pointer, :int], :void, **opts
+      attach_function :zsock_gssapi_plaintext, [:pointer], :int, **opts
+      attach_function :zsock_set_gssapi_plaintext, [:pointer, :int], :void, **opts
+      attach_function :zsock_gssapi_principal, [:pointer], :pointer, **opts
+      attach_function :zsock_set_gssapi_principal, [:pointer, :string], :void, **opts
+      attach_function :zsock_gssapi_service_principal, [:pointer], :pointer, **opts
+      attach_function :zsock_set_gssapi_service_principal, [:pointer, :string], :void, **opts
+      attach_function :zsock_ipv6, [:pointer], :int, **opts
+      attach_function :zsock_set_ipv6, [:pointer, :int], :void, **opts
+      attach_function :zsock_immediate, [:pointer], :int, **opts
+      attach_function :zsock_set_immediate, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_router_raw, [:pointer, :int], :void, **opts
+      attach_function :zsock_ipv4only, [:pointer], :int, **opts
+      attach_function :zsock_set_ipv4only, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_delay_attach_on_connect, [:pointer, :int], :void, **opts
+      attach_function :zsock_type, [:pointer], :int, **opts
+      attach_function :zsock_sndhwm, [:pointer], :int, **opts
+      attach_function :zsock_set_sndhwm, [:pointer, :int], :void, **opts
+      attach_function :zsock_rcvhwm, [:pointer], :int, **opts
+      attach_function :zsock_set_rcvhwm, [:pointer, :int], :void, **opts
+      attach_function :zsock_affinity, [:pointer], :int, **opts
+      attach_function :zsock_set_affinity, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_subscribe, [:pointer, :string], :void, **opts
+      attach_function :zsock_set_unsubscribe, [:pointer, :string], :void, **opts
+      attach_function :zsock_identity, [:pointer], :pointer, **opts
+      attach_function :zsock_set_identity, [:pointer, :string], :void, **opts
+      attach_function :zsock_rate, [:pointer], :int, **opts
+      attach_function :zsock_set_rate, [:pointer, :int], :void, **opts
+      attach_function :zsock_recovery_ivl, [:pointer], :int, **opts
+      attach_function :zsock_set_recovery_ivl, [:pointer, :int], :void, **opts
+      attach_function :zsock_sndbuf, [:pointer], :int, **opts
+      attach_function :zsock_set_sndbuf, [:pointer, :int], :void, **opts
+      attach_function :zsock_rcvbuf, [:pointer], :int, **opts
+      attach_function :zsock_set_rcvbuf, [:pointer, :int], :void, **opts
+      attach_function :zsock_linger, [:pointer], :int, **opts
+      attach_function :zsock_set_linger, [:pointer, :int], :void, **opts
+      attach_function :zsock_reconnect_ivl, [:pointer], :int, **opts
+      attach_function :zsock_set_reconnect_ivl, [:pointer, :int], :void, **opts
+      attach_function :zsock_reconnect_ivl_max, [:pointer], :int, **opts
+      attach_function :zsock_set_reconnect_ivl_max, [:pointer, :int], :void, **opts
+      attach_function :zsock_backlog, [:pointer], :int, **opts
+      attach_function :zsock_set_backlog, [:pointer, :int], :void, **opts
+      attach_function :zsock_maxmsgsize, [:pointer], :int, **opts
+      attach_function :zsock_set_maxmsgsize, [:pointer, :int], :void, **opts
+      attach_function :zsock_multicast_hops, [:pointer], :int, **opts
+      attach_function :zsock_set_multicast_hops, [:pointer, :int], :void, **opts
+      attach_function :zsock_rcvtimeo, [:pointer], :int, **opts
+      attach_function :zsock_set_rcvtimeo, [:pointer, :int], :void, **opts
+      attach_function :zsock_sndtimeo, [:pointer], :int, **opts
+      attach_function :zsock_set_sndtimeo, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_xpub_verbose, [:pointer, :int], :void, **opts
+      attach_function :zsock_tcp_keepalive, [:pointer], :int, **opts
+      attach_function :zsock_set_tcp_keepalive, [:pointer, :int], :void, **opts
+      attach_function :zsock_tcp_keepalive_idle, [:pointer], :int, **opts
+      attach_function :zsock_set_tcp_keepalive_idle, [:pointer, :int], :void, **opts
+      attach_function :zsock_tcp_keepalive_cnt, [:pointer], :int, **opts
+      attach_function :zsock_set_tcp_keepalive_cnt, [:pointer, :int], :void, **opts
+      attach_function :zsock_tcp_keepalive_intvl, [:pointer], :int, **opts
+      attach_function :zsock_set_tcp_keepalive_intvl, [:pointer, :int], :void, **opts
+      attach_function :zsock_tcp_accept_filter, [:pointer], :pointer, **opts
+      attach_function :zsock_set_tcp_accept_filter, [:pointer, :string], :void, **opts
+      attach_function :zsock_rcvmore, [:pointer], :int, **opts
+      attach_function :zsock_fd, [:pointer], :pointer, **opts
+      attach_function :zsock_events, [:pointer], :int, **opts
+      attach_function :zsock_last_endpoint, [:pointer], :pointer, **opts
+      attach_function :zsock_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zsock'
+
+      attach_function :zstr_recv, [:pointer], :pointer, **opts
+      attach_function :zstr_recvx, [:pointer, :pointer, :varargs], :int, **opts
+      attach_function :zstr_send, [:pointer, :string], :int, **opts
+      attach_function :zstr_sendm, [:pointer, :string], :int, **opts
+      attach_function :zstr_sendf, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zstr_sendfm, [:pointer, :string, :varargs], :int, **opts
+      attach_function :zstr_sendx, [:pointer, :string, :varargs], :int, **opts
+      begin # DRAFT method
+        attach_function :zstr_str, [:pointer], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function zstr_str() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      attach_function :zstr_free, [:pointer], :void, **opts
+      attach_function :zstr_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zstr'
+
+      begin # DRAFT method
+        attach_function :ztimerset_new, [], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_new() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_destroy, [:pointer], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_destroy() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_add, [:pointer, :size_t, :pointer, :pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_add() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_cancel, [:pointer, :int], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_cancel() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_set_interval, [:pointer, :int, :size_t], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_set_interval() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_reset, [:pointer, :int], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_reset() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_timeout, [:pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_timeout() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_execute, [:pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_execute() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztimerset_test, [:bool], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztimerset_test() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+
+      require_relative 'ffi/ztimerset'
+
+      begin # DRAFT method
+        attach_function :ztrie_new, [:pointer], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_new() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_destroy, [:pointer], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_destroy() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_insert_route, [:pointer, :string, :pointer, :pointer], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_insert_route() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_remove_route, [:pointer, :string], :int, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_remove_route() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_matches, [:pointer, :string], :bool, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_matches() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_hit_data, [:pointer], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_hit_data() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_hit_parameter_count, [:pointer], :size_t, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_hit_parameter_count() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_hit_parameters, [:pointer], :pointer, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_hit_parameters() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_hit_asterisk_match, [:pointer], :string, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_hit_asterisk_match() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_print, [:pointer], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_print() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+      begin # DRAFT method
+        attach_function :ztrie_test, [:bool], :void, **opts
+      rescue ::FFI::NotFoundError
+        if $VERBOSE || $DEBUG
+          warn "The function ztrie_test() can't be used through " +
+               "this Ruby binding because it's not available."
+        end
+      end
+
+      require_relative 'ffi/ztrie'
+
+      attach_function :zuuid_new, [], :pointer, **opts
+      attach_function :zuuid_new_from, [:pointer], :pointer, **opts
+      attach_function :zuuid_destroy, [:pointer], :void, **opts
+      attach_function :zuuid_set, [:pointer, :pointer], :void, **opts
+      attach_function :zuuid_set_str, [:pointer, :string], :int, **opts
+      attach_function :zuuid_data, [:pointer], :pointer, **opts
+      attach_function :zuuid_size, [:pointer], :size_t, **opts
+      attach_function :zuuid_str, [:pointer], :string, **opts
+      attach_function :zuuid_str_canonical, [:pointer], :string, **opts
+      attach_function :zuuid_export, [:pointer, :pointer], :void, **opts
+      attach_function :zuuid_eq, [:pointer, :pointer], :bool, **opts
+      attach_function :zuuid_neq, [:pointer, :pointer], :bool, **opts
+      attach_function :zuuid_dup, [:pointer], :pointer, **opts
+      attach_function :zuuid_test, [:bool], :void, **opts
+
+      require_relative 'ffi/zuuid'
+    end
+  end
+end
+
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################