Make changes required for CI

103 files changed, 66131 insertions, 10 deletions

diff --git a/bpkg/argument-grouping.cxx b/bpkg/argument-grouping.cxx
new file mode 100644
index 0000000..998b7ea
--- /dev/null
+++ b/bpkg/argument-grouping.cxx
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/argument-grouping.hxx>
+
+#include <map>
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_argument_grouping_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg\033[0m \033[1m{\033[0m \033[4moptions\033[0m \033[1m}+\033[0m \033[4margument\033[0m \033[1m+{\033[0m \033[4moptions\033[0m \033[1m}\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "For certain commands certain options and command line variables can be grouped" << ::std::endl
+       << "to only apply to specific arguments. This help topic describes the argument" << ::std::endl
+       << "grouping facility used for this purpose." << ::std::endl
+       << ::std::endl
+       << "Groups can be specified before (leading) and/or after (trailing) the argument" << ::std::endl
+       << "they apply to. A leading group starts with '\033[1m{\033[0m' and ends with '\033[1m}+\033[0m' while a" << ::std::endl
+       << "trailing group starts with '\033[1m+{\033[0m' and ends with '\033[1m}\033[0m'. For example:" << ::std::endl
+       << ::std::endl
+       << "{ --foo --bar }+ arg   # 'arg' with '--foo' '--bar'" << ::std::endl
+       << "arg +{ fox=1 baz=2 }   # 'arg' with 'fox=1' 'baz=2'" << ::std::endl
+       << ::std::endl
+       << "Multiple leading and/or trailing groups can be specified for the same argument." << ::std::endl
+       << "For example:" << ::std::endl
+       << ::std::endl
+       << "{ -f }+ { -b }+ arg +{ f=1 } +{ b=2 } # 'arg' with '-f' 'b' 'f=1' 'b=2'" << ::std::endl
+       << ::std::endl
+       << "The group applies to a single argument only unless multiple arguments are" << ::std::endl
+       << "themselves grouped with '\033[1m{\033[0m' and '\033[1m}\033[0m'. For example:" << ::std::endl
+       << ::std::endl
+       << "{ --foo }+ arg1  arg2 +{ --bar }      # 'arg1' with '--foo'" << ::std::endl
+       << "                                      # 'arg2' with '--bar'" << ::std::endl
+       << ::std::endl
+       << "{ --foo }+ { arg1  arg2 } +{ --bar }  # 'arg1' with '--foo' '--bar'" << ::std::endl
+       << "                                      # 'arg2' with '--foo' '--bar'" << ::std::endl
+       << ::std::endl
+       << "The group separators ('\033[1m{\033[0m', '\033[1m}+'\033[0m, etc) must be separate command line arguments." << ::std::endl
+       << "In particular, they must not be adjacent either to the arguments inside the" << ::std::endl
+       << "group nor to the argument they apply to. All such cases will be treated as" << ::std::endl
+       << "ordinary arguments. For example:" << ::std::endl
+       << ::std::endl
+       << "{--foo}+ arg   # '{--foo}+' ..." << ::std::endl
+       << "arg+{ --foo }  # 'arg+{' ..." << ::std::endl
+       << ::std::endl
+       << "If one of the group separators needs to be specified as an argument verbatim," << ::std::endl
+       << "then it must be escaped with '\033[1m\\\033[0m'. For example:" << ::std::endl
+       << ::std::endl
+       << "}             # error: unexpected group separator" << ::std::endl
+       << "}x            # '}x'" << ::std::endl
+       << "\\}            # '}'" << ::std::endl
+       << "{ \\}+ }+ arg  # 'arg' with '}+'" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/argument-grouping.hxx b/bpkg/argument-grouping.hxx
new file mode 100644
index 0000000..64019de
--- /dev/null
+++ b/bpkg/argument-grouping.hxx
@@ -0,0 +1,31 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_ARGUMENT_GROUPING_HXX
+#define BPKG_ARGUMENT_GROUPING_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_argument_grouping_usage (::std::ostream&,
+                                      ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_ARGUMENT_GROUPING_HXX
diff --git a/bpkg/bpkg-options.cxx b/bpkg/bpkg-options.cxx
new file mode 100644
index 0000000..5604d2a
--- /dev/null
+++ b/bpkg/bpkg-options.cxx
@@ -0,0 +1,1664 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/bpkg-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // commands
+  //
+
+  commands::
+  commands ()
+  : help_ (),
+    cfg_create_ (),
+    cfg_info_ (),
+    cfg_link_ (),
+    cfg_unlink_ (),
+    rep_info_ (),
+    rep_add_ (),
+    rep_remove_ (),
+    rep_list_ (),
+    rep_fetch_ (),
+    rep_create_ (),
+    pkg_status_ (),
+    pkg_build_ (),
+    pkg_drop_ (),
+    pkg_install_ (),
+    pkg_uninstall_ (),
+    pkg_update_ (),
+    pkg_test_ (),
+    pkg_clean_ (),
+    pkg_bindist_ (),
+    pkg_verify_ (),
+    pkg_fetch_ (),
+    pkg_unpack_ (),
+    pkg_checkout_ (),
+    pkg_configure_ (),
+    pkg_disfigure_ (),
+    pkg_purge_ ()
+  {
+  }
+
+  bool commands::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool commands::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool commands::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool commands::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool commands::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void commands::
+  merge (const commands& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    if (a.help_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->help_, a.help_);
+    }
+
+    if (a.cfg_create_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cfg_create_, a.cfg_create_);
+    }
+
+    if (a.cfg_info_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cfg_info_, a.cfg_info_);
+    }
+
+    if (a.cfg_link_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cfg_link_, a.cfg_link_);
+    }
+
+    if (a.cfg_unlink_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cfg_unlink_, a.cfg_unlink_);
+    }
+
+    if (a.rep_info_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->rep_info_, a.rep_info_);
+    }
+
+    if (a.rep_add_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->rep_add_, a.rep_add_);
+    }
+
+    if (a.rep_remove_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->rep_remove_, a.rep_remove_);
+    }
+
+    if (a.rep_list_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->rep_list_, a.rep_list_);
+    }
+
+    if (a.rep_fetch_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->rep_fetch_, a.rep_fetch_);
+    }
+
+    if (a.rep_create_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->rep_create_, a.rep_create_);
+    }
+
+    if (a.pkg_status_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_status_, a.pkg_status_);
+    }
+
+    if (a.pkg_build_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_build_, a.pkg_build_);
+    }
+
+    if (a.pkg_drop_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_drop_, a.pkg_drop_);
+    }
+
+    if (a.pkg_install_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_install_, a.pkg_install_);
+    }
+
+    if (a.pkg_uninstall_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_uninstall_, a.pkg_uninstall_);
+    }
+
+    if (a.pkg_update_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_update_, a.pkg_update_);
+    }
+
+    if (a.pkg_test_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_test_, a.pkg_test_);
+    }
+
+    if (a.pkg_clean_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_clean_, a.pkg_clean_);
+    }
+
+    if (a.pkg_bindist_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_bindist_, a.pkg_bindist_);
+    }
+
+    if (a.pkg_verify_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_verify_, a.pkg_verify_);
+    }
+
+    if (a.pkg_fetch_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_fetch_, a.pkg_fetch_);
+    }
+
+    if (a.pkg_unpack_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_unpack_, a.pkg_unpack_);
+    }
+
+    if (a.pkg_checkout_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_checkout_, a.pkg_checkout_);
+    }
+
+    if (a.pkg_configure_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_configure_, a.pkg_configure_);
+    }
+
+    if (a.pkg_disfigure_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_disfigure_, a.pkg_disfigure_);
+    }
+
+    if (a.pkg_purge_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->pkg_purge_, a.pkg_purge_);
+    }
+  }
+
+  ::bpkg::cli::usage_para commands::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mCOMMANDS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1mhelp\033[0m [\033[4mtopic\033[0m]              \033[1mbpkg-help(1)\033[0m -- show help for a command or help topic" << ::std::endl;
+
+    os << "\033[1mcfg-create\033[0m|\033[1mcreate\033[0m         \033[1mbpkg-cfg-create(1)\033[0m -- create configuration" << ::std::endl;
+
+    os << "\033[1mcfg-info\033[0m                  \033[1mbpkg-cfg-info(1)\033[0m -- print configuration information" << ::std::endl;
+
+    os << "\033[1mcfg-link\033[0m|\033[1mlink\033[0m             \033[1mbpkg-cfg-link(1)\033[0m -- link configuration" << ::std::endl;
+
+    os << "\033[1mcfg-unlink\033[0m|\033[1munlink\033[0m         \033[1mbpkg-cfg-unlink(1)\033[0m -- unlink configuration" << ::std::endl;
+
+    os << "\033[1mrep-info\033[0m                  \033[1mbpkg-rep-info(1)\033[0m -- print repository information" << ::std::endl;
+
+    os << "\033[1mrep-add\033[0m|\033[1madd\033[0m               \033[1mbpkg-rep-add(1)\033[0m -- add repository to configuration" << ::std::endl;
+
+    os << "\033[1mrep-remove\033[0m|\033[1mremove\033[0m         \033[1mbpkg-rep-remove(1)\033[0m -- remove repository from" << ::std::endl
+       << "                          configuration" << ::std::endl;
+
+    os << "\033[1mrep-list\033[0m|\033[1mlist\033[0m             \033[1mbpkg-rep-list(1)\033[0m -- list repositories in" << ::std::endl
+       << "                          configuration" << ::std::endl;
+
+    os << "\033[1mrep-fetch\033[0m|\033[1mfetch\033[0m           \033[1mbpkg-rep-fetch(1)\033[0m -- fetch list of available packages" << ::std::endl;
+
+    os << "\033[1mrep-create\033[0m                \033[1mbpkg-rep-create(1)\033[0m -- create repository" << ::std::endl;
+
+    os << "\033[1mpkg-status\033[0m|\033[1mstatus\033[0m         \033[1mbpkg-pkg-status(1)\033[0m -- print package status" << ::std::endl;
+
+    os << "\033[1mpkg-build\033[0m|\033[1mbuild\033[0m           \033[1mbpkg-pkg-build(1)\033[0m -- build package" << ::std::endl;
+
+    os << "\033[1mpkg-drop\033[0m|\033[1mdrop\033[0m             \033[1mbpkg-pkg-drop(1)\033[0m -- drop package" << ::std::endl;
+
+    os << "\033[1mpkg-install\033[0m|\033[1minstall\033[0m       \033[1mbpkg-pkg-install(1)\033[0m -- install package" << ::std::endl;
+
+    os << "\033[1mpkg-uninstall\033[0m|\033[1muninstall\033[0m   \033[1mbpkg-pkg-uninstall(1)\033[0m -- uninstall package" << ::std::endl;
+
+    os << "\033[1mpkg-update\033[0m|\033[1mupdate\033[0m         \033[1mbpkg-pkg-update(1)\033[0m -- update package" << ::std::endl;
+
+    os << "\033[1mpkg-test\033[0m|\033[1mtest\033[0m             \033[1mbpkg-pkg-test(1)\033[0m -- test package" << ::std::endl;
+
+    os << "\033[1mpkg-clean\033[0m|\033[1mclean\033[0m           \033[1mbpkg-pkg-clean(1)\033[0m -- clean package" << ::std::endl;
+
+    os << "\033[1mpkg-bindist\033[0m|\033[1mbindist\033[0m       \033[1mbpkg-pkg-bindist(1)\033[0m -- generate binary distribution" << ::std::endl
+       << "                          package" << ::std::endl;
+
+    os << "\033[1mpkg-verify\033[0m                \033[1mbpkg-pkg-verify(1)\033[0m -- verify package archive" << ::std::endl;
+
+    os << "\033[1mpkg-fetch\033[0m                 \033[1mbpkg-pkg-fetch(1)\033[0m -- fetch package archive" << ::std::endl;
+
+    os << "\033[1mpkg-unpack\033[0m                \033[1mbpkg-pkg-unpack(1)\033[0m -- unpack package archive" << ::std::endl;
+
+    os << "\033[1mpkg-checkout\033[0m              \033[1mbpkg-pkg-checkout(1)\033[0m -- check out package version" << ::std::endl;
+
+    os << "\033[1mpkg-configure\033[0m             \033[1mbpkg-pkg-configure(1)\033[0m -- configure package" << ::std::endl;
+
+    os << "\033[1mpkg-disfigure\033[0m             \033[1mbpkg-pkg-disfigure(1)\033[0m -- disfigure package" << ::std::endl;
+
+    os << "\033[1mpkg-purge\033[0m                 \033[1mbpkg-pkg-purge(1)\033[0m -- purge package" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (commands&, ::bpkg::cli::scanner&)>
+  _cli_commands_map;
+
+  static _cli_commands_map _cli_commands_map_;
+
+  struct _cli_commands_map_init
+  {
+    _cli_commands_map_init ()
+    {
+      _cli_commands_map_["help"] =
+      &::bpkg::cli::thunk< commands, &commands::help_ >;
+      _cli_commands_map_["cfg-create"] =
+      &::bpkg::cli::thunk< commands, &commands::cfg_create_ >;
+      _cli_commands_map_["create"] =
+      &::bpkg::cli::thunk< commands, &commands::cfg_create_ >;
+      _cli_commands_map_["cfg-info"] =
+      &::bpkg::cli::thunk< commands, &commands::cfg_info_ >;
+      _cli_commands_map_["cfg-link"] =
+      &::bpkg::cli::thunk< commands, &commands::cfg_link_ >;
+      _cli_commands_map_["link"] =
+      &::bpkg::cli::thunk< commands, &commands::cfg_link_ >;
+      _cli_commands_map_["cfg-unlink"] =
+      &::bpkg::cli::thunk< commands, &commands::cfg_unlink_ >;
+      _cli_commands_map_["unlink"] =
+      &::bpkg::cli::thunk< commands, &commands::cfg_unlink_ >;
+      _cli_commands_map_["rep-info"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_info_ >;
+      _cli_commands_map_["rep-add"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_add_ >;
+      _cli_commands_map_["add"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_add_ >;
+      _cli_commands_map_["rep-remove"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_remove_ >;
+      _cli_commands_map_["remove"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_remove_ >;
+      _cli_commands_map_["rep-list"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_list_ >;
+      _cli_commands_map_["list"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_list_ >;
+      _cli_commands_map_["rep-fetch"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_fetch_ >;
+      _cli_commands_map_["fetch"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_fetch_ >;
+      _cli_commands_map_["rep-create"] =
+      &::bpkg::cli::thunk< commands, &commands::rep_create_ >;
+      _cli_commands_map_["pkg-status"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_status_ >;
+      _cli_commands_map_["status"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_status_ >;
+      _cli_commands_map_["pkg-build"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_build_ >;
+      _cli_commands_map_["build"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_build_ >;
+      _cli_commands_map_["pkg-drop"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_drop_ >;
+      _cli_commands_map_["drop"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_drop_ >;
+      _cli_commands_map_["pkg-install"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_install_ >;
+      _cli_commands_map_["install"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_install_ >;
+      _cli_commands_map_["pkg-uninstall"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_uninstall_ >;
+      _cli_commands_map_["uninstall"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_uninstall_ >;
+      _cli_commands_map_["pkg-update"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_update_ >;
+      _cli_commands_map_["update"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_update_ >;
+      _cli_commands_map_["pkg-test"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_test_ >;
+      _cli_commands_map_["test"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_test_ >;
+      _cli_commands_map_["pkg-clean"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_clean_ >;
+      _cli_commands_map_["clean"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_clean_ >;
+      _cli_commands_map_["pkg-bindist"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_bindist_ >;
+      _cli_commands_map_["bindist"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_bindist_ >;
+      _cli_commands_map_["pkg-verify"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_verify_ >;
+      _cli_commands_map_["pkg-fetch"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_fetch_ >;
+      _cli_commands_map_["pkg-unpack"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_unpack_ >;
+      _cli_commands_map_["pkg-checkout"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_checkout_ >;
+      _cli_commands_map_["pkg-configure"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_configure_ >;
+      _cli_commands_map_["pkg-disfigure"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_disfigure_ >;
+      _cli_commands_map_["pkg-purge"] =
+      &::bpkg::cli::thunk< commands, &commands::pkg_purge_ >;
+    }
+  };
+
+  static _cli_commands_map_init _cli_commands_map_init_;
+
+  bool commands::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_commands_map::const_iterator i (_cli_commands_map_.find (o));
+
+    if (i != _cli_commands_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool commands::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // topics
+  //
+
+  topics::
+  topics ()
+  : common_options_ (),
+    default_options_files_ (),
+    repository_types_ (),
+    repository_signing_ (),
+    argument_grouping_ ()
+  {
+  }
+
+  bool topics::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool topics::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool topics::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool topics::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool topics::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void topics::
+  merge (const topics& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    if (a.common_options_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->common_options_, a.common_options_);
+    }
+
+    if (a.default_options_files_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->default_options_files_, a.default_options_files_);
+    }
+
+    if (a.repository_types_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->repository_types_, a.repository_types_);
+    }
+
+    if (a.repository_signing_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->repository_signing_, a.repository_signing_);
+    }
+
+    if (a.argument_grouping_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->argument_grouping_, a.argument_grouping_);
+    }
+  }
+
+  ::bpkg::cli::usage_para topics::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mHELP TOPICS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1mcommon-options\033[0m            \033[1mbpkg-common-options(1)\033[0m -- details on common options" << ::std::endl;
+
+    os << "\033[1mdefault-options-files\033[0m     \033[1mbpkg-default-options-files(1)\033[0m -- specifying default" << ::std::endl
+       << "                          options" << ::std::endl;
+
+    os << "\033[1mrepository-types\033[0m          \033[1mbpkg-repository-types(1)\033[0m -- repository types," << ::std::endl
+       << "                          structure, and URLs" << ::std::endl;
+
+    os << "\033[1mrepository-signing\033[0m        \033[1mbpkg-repository-signing(1)\033[0m -- how to sign repository" << ::std::endl;
+
+    os << "\033[1margument-grouping\033[0m         \033[1mbpkg-argument-grouping(1)\033[0m -- argument grouping" << ::std::endl
+       << "                          facility" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (topics&, ::bpkg::cli::scanner&)>
+  _cli_topics_map;
+
+  static _cli_topics_map _cli_topics_map_;
+
+  struct _cli_topics_map_init
+  {
+    _cli_topics_map_init ()
+    {
+      _cli_topics_map_["common-options"] =
+      &::bpkg::cli::thunk< topics, &topics::common_options_ >;
+      _cli_topics_map_["default-options-files"] =
+      &::bpkg::cli::thunk< topics, &topics::default_options_files_ >;
+      _cli_topics_map_["repository-types"] =
+      &::bpkg::cli::thunk< topics, &topics::repository_types_ >;
+      _cli_topics_map_["repository-signing"] =
+      &::bpkg::cli::thunk< topics, &topics::repository_signing_ >;
+      _cli_topics_map_["argument-grouping"] =
+      &::bpkg::cli::thunk< topics, &topics::argument_grouping_ >;
+    }
+  };
+
+  static _cli_topics_map_init _cli_topics_map_init_;
+
+  bool topics::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_topics_map::const_iterator i (_cli_topics_map_.find (o));
+
+    if (i != _cli_topics_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool topics::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // options
+  //
+
+  options::
+  options ()
+  : help_ (),
+    version_ ()
+  {
+  }
+
+  bool options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void options::
+  merge (const options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+
+    if (a.help_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->help_, a.help_);
+    }
+
+    if (a.version_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->version_, a.version_);
+    }
+  }
+
+  ::bpkg::cli::usage_para options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (options&, ::bpkg::cli::scanner&)>
+  _cli_options_map;
+
+  static _cli_options_map _cli_options_map_;
+
+  struct _cli_options_map_init
+  {
+    _cli_options_map_init ()
+    {
+      _cli_options_map_["--help"] =
+      &::bpkg::cli::thunk< options, &options::help_ >;
+      _cli_options_map_["--version"] =
+      &::bpkg::cli::thunk< options, &options::version_ >;
+    }
+  };
+
+  static _cli_options_map_init _cli_options_map_init_;
+
+  bool options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_options_map::const_iterator i (_cli_options_map_.find (o));
+
+    if (i != _cli_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg --help\033[0m" << ::std::endl
+       << "\033[1mbpkg --version\033[0m" << ::std::endl
+       << "\033[1mbpkg help\033[0m [\033[4mcommand\033[0m | \033[4mtopic\033[0m]" << ::std::endl
+       << "\033[1mbpkg\033[0m [\033[4mcommon-options\033[0m] \033[4mcommand\033[0m [\033[4mcommand-options\033[0m] \033[4mcommand-args\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mbuild2\033[0m package dependency manager is used to manipulate build" << ::std::endl
+       << "configurations, packages, and repositories using a set of commands that are" << ::std::endl
+       << "summarized below." << ::std::endl
+       << ::std::endl
+       << "For a detailed description of any command or help topic, use the \033[1mhelp\033[0m command" << ::std::endl
+       << "or see the corresponding man page (the man pages have the \033[1mbpkg-\033[0m prefix, for" << ::std::endl
+       << "example \033[1mbpkg-help(1)\033[0m). Note also that \033[4mcommand-options\033[0m and \033[4mcommand-args\033[0m can be" << ::std::endl
+       << "specified in any order and \033[4mcommon-options\033[0m can be specified as part of" << ::std::endl
+       << "\033[4mcommand-options\033[0m." << ::std::endl;
+
+    p = ::bpkg::commands::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    p = ::bpkg::topics::print_usage (os, p);
+
+    p = ::bpkg::options::print_usage (os, p);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mENVIRONMENT\033[0m" << ::std::endl
+       << ::std::endl
+       << "Commands executed by \033[1mbpkg\033[0m while the current and linked build configuration" << ::std::endl
+       << "databases are open will have the \033[1mBPKG_OPEN_CONFIGS\033[0m environment variable set to" << ::std::endl
+       << "the space-separated, \033[1m\"\033[0m-quoted list of absolute and normalized configuration" << ::std::endl
+       << "directory paths. This can be used by build system hooks and/or programs that" << ::std::endl
+       << "they execute." << ::std::endl;
+
+    os << std::endl
+       << "\033[1mEXIT STATUS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1m0\033[0m" << ::std::endl
+       << "    Success." << ::std::endl
+       << "\033[1m1\033[0m" << ::std::endl
+       << "    Fatal error." << ::std::endl
+       << "\033[1m2\033[0m" << ::std::endl
+       << "    Recoverable error which is likely to disappear if the command is" << ::std::endl
+       << "    re-executed." << ::std::endl
+       << ::std::endl
+       << "\033[1mENVIRONMENT\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mBPKG_DEF_OPT\033[0m environment variable is used to suppress loading of default" << ::std::endl
+       << "options files in nested \033[1mbpkg\033[0m invocations. Its values are \033[1mfalse\033[0m or \033[1m0\033[0m to suppress" << ::std::endl
+       << "and \033[1mtrue\033[0m or \033[1m1\033[0m to load." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/bpkg-options.hxx b/bpkg/bpkg-options.hxx
new file mode 100644
index 0000000..9dda684
--- /dev/null
+++ b/bpkg/bpkg-options.hxx
@@ -0,0 +1,391 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_BPKG_OPTIONS_HXX
+#define BPKG_BPKG_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class commands
+  {
+    public:
+    commands ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const commands&);
+
+    // Option accessors.
+    //
+    const bool&
+    help () const;
+
+    const bool&
+    cfg_create () const;
+
+    const bool&
+    cfg_info () const;
+
+    const bool&
+    cfg_link () const;
+
+    const bool&
+    cfg_unlink () const;
+
+    const bool&
+    rep_info () const;
+
+    const bool&
+    rep_add () const;
+
+    const bool&
+    rep_remove () const;
+
+    const bool&
+    rep_list () const;
+
+    const bool&
+    rep_fetch () const;
+
+    const bool&
+    rep_create () const;
+
+    const bool&
+    pkg_status () const;
+
+    const bool&
+    pkg_build () const;
+
+    const bool&
+    pkg_drop () const;
+
+    const bool&
+    pkg_install () const;
+
+    const bool&
+    pkg_uninstall () const;
+
+    const bool&
+    pkg_update () const;
+
+    const bool&
+    pkg_test () const;
+
+    const bool&
+    pkg_clean () const;
+
+    const bool&
+    pkg_bindist () const;
+
+    const bool&
+    pkg_verify () const;
+
+    const bool&
+    pkg_fetch () const;
+
+    const bool&
+    pkg_unpack () const;
+
+    const bool&
+    pkg_checkout () const;
+
+    const bool&
+    pkg_configure () const;
+
+    const bool&
+    pkg_disfigure () const;
+
+    const bool&
+    pkg_purge () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool help_;
+    bool cfg_create_;
+    bool cfg_info_;
+    bool cfg_link_;
+    bool cfg_unlink_;
+    bool rep_info_;
+    bool rep_add_;
+    bool rep_remove_;
+    bool rep_list_;
+    bool rep_fetch_;
+    bool rep_create_;
+    bool pkg_status_;
+    bool pkg_build_;
+    bool pkg_drop_;
+    bool pkg_install_;
+    bool pkg_uninstall_;
+    bool pkg_update_;
+    bool pkg_test_;
+    bool pkg_clean_;
+    bool pkg_bindist_;
+    bool pkg_verify_;
+    bool pkg_fetch_;
+    bool pkg_unpack_;
+    bool pkg_checkout_;
+    bool pkg_configure_;
+    bool pkg_disfigure_;
+    bool pkg_purge_;
+  };
+
+  class topics
+  {
+    public:
+    topics ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const topics&);
+
+    // Option accessors.
+    //
+    const bool&
+    common_options () const;
+
+    const bool&
+    default_options_files () const;
+
+    const bool&
+    repository_types () const;
+
+    const bool&
+    repository_signing () const;
+
+    const bool&
+    argument_grouping () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool common_options_;
+    bool default_options_files_;
+    bool repository_types_;
+    bool repository_signing_;
+    bool argument_grouping_;
+  };
+
+  class options: public ::bpkg::common_options
+  {
+    public:
+    options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const options&);
+
+    // Option accessors.
+    //
+    const bool&
+    help () const;
+
+    const bool&
+    version () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool help_;
+    bool version_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_usage (::std::ostream&,
+                    ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/bpkg-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_BPKG_OPTIONS_HXX
diff --git a/bpkg/bpkg-options.ixx b/bpkg/bpkg-options.ixx
new file mode 100644
index 0000000..fe5b6d4
--- /dev/null
+++ b/bpkg/bpkg-options.ixx
@@ -0,0 +1,231 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // commands
+  //
+
+  inline const bool& commands::
+  help () const
+  {
+    return this->help_;
+  }
+
+  inline const bool& commands::
+  cfg_create () const
+  {
+    return this->cfg_create_;
+  }
+
+  inline const bool& commands::
+  cfg_info () const
+  {
+    return this->cfg_info_;
+  }
+
+  inline const bool& commands::
+  cfg_link () const
+  {
+    return this->cfg_link_;
+  }
+
+  inline const bool& commands::
+  cfg_unlink () const
+  {
+    return this->cfg_unlink_;
+  }
+
+  inline const bool& commands::
+  rep_info () const
+  {
+    return this->rep_info_;
+  }
+
+  inline const bool& commands::
+  rep_add () const
+  {
+    return this->rep_add_;
+  }
+
+  inline const bool& commands::
+  rep_remove () const
+  {
+    return this->rep_remove_;
+  }
+
+  inline const bool& commands::
+  rep_list () const
+  {
+    return this->rep_list_;
+  }
+
+  inline const bool& commands::
+  rep_fetch () const
+  {
+    return this->rep_fetch_;
+  }
+
+  inline const bool& commands::
+  rep_create () const
+  {
+    return this->rep_create_;
+  }
+
+  inline const bool& commands::
+  pkg_status () const
+  {
+    return this->pkg_status_;
+  }
+
+  inline const bool& commands::
+  pkg_build () const
+  {
+    return this->pkg_build_;
+  }
+
+  inline const bool& commands::
+  pkg_drop () const
+  {
+    return this->pkg_drop_;
+  }
+
+  inline const bool& commands::
+  pkg_install () const
+  {
+    return this->pkg_install_;
+  }
+
+  inline const bool& commands::
+  pkg_uninstall () const
+  {
+    return this->pkg_uninstall_;
+  }
+
+  inline const bool& commands::
+  pkg_update () const
+  {
+    return this->pkg_update_;
+  }
+
+  inline const bool& commands::
+  pkg_test () const
+  {
+    return this->pkg_test_;
+  }
+
+  inline const bool& commands::
+  pkg_clean () const
+  {
+    return this->pkg_clean_;
+  }
+
+  inline const bool& commands::
+  pkg_bindist () const
+  {
+    return this->pkg_bindist_;
+  }
+
+  inline const bool& commands::
+  pkg_verify () const
+  {
+    return this->pkg_verify_;
+  }
+
+  inline const bool& commands::
+  pkg_fetch () const
+  {
+    return this->pkg_fetch_;
+  }
+
+  inline const bool& commands::
+  pkg_unpack () const
+  {
+    return this->pkg_unpack_;
+  }
+
+  inline const bool& commands::
+  pkg_checkout () const
+  {
+    return this->pkg_checkout_;
+  }
+
+  inline const bool& commands::
+  pkg_configure () const
+  {
+    return this->pkg_configure_;
+  }
+
+  inline const bool& commands::
+  pkg_disfigure () const
+  {
+    return this->pkg_disfigure_;
+  }
+
+  inline const bool& commands::
+  pkg_purge () const
+  {
+    return this->pkg_purge_;
+  }
+
+  // topics
+  //
+
+  inline const bool& topics::
+  common_options () const
+  {
+    return this->common_options_;
+  }
+
+  inline const bool& topics::
+  default_options_files () const
+  {
+    return this->default_options_files_;
+  }
+
+  inline const bool& topics::
+  repository_types () const
+  {
+    return this->repository_types_;
+  }
+
+  inline const bool& topics::
+  repository_signing () const
+  {
+    return this->repository_signing_;
+  }
+
+  inline const bool& topics::
+  argument_grouping () const
+  {
+    return this->argument_grouping_;
+  }
+
+  // options
+  //
+
+  inline const bool& options::
+  help () const
+  {
+    return this->help_;
+  }
+
+  inline const bool& options::
+  version () const
+  {
+    return this->version_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/cfg-create-options.cxx b/bpkg/cfg-create-options.cxx
new file mode 100644
index 0000000..27979a1
--- /dev/null
+++ b/bpkg/cfg-create-options.cxx
@@ -0,0 +1,883 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/cfg-create-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // cfg_create_options
+  //
+
+  cfg_create_options::
+  cfg_create_options ()
+  : directory_ ("."),
+    directory_specified_ (false),
+    existing_ (),
+    wipe_ (),
+    host_config_ (),
+    host_config_specified_ (false),
+    no_host_config_ (),
+    build2_config_ (),
+    build2_config_specified_ (false),
+    no_build2_config_ (),
+    name_ (),
+    name_specified_ (false),
+    type_ ("target"),
+    type_specified_ (false),
+    uuid_ (),
+    uuid_specified_ (false)
+  {
+  }
+
+  bool cfg_create_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_create_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_create_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_create_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_create_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void cfg_create_options::
+  merge (const cfg_create_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+
+    if (a.directory_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->directory_, a.directory_);
+      this->directory_specified_ = true;
+    }
+
+    if (a.existing_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->existing_, a.existing_);
+    }
+
+    if (a.wipe_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->wipe_, a.wipe_);
+    }
+
+    if (a.host_config_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->host_config_, a.host_config_);
+      this->host_config_specified_ = true;
+    }
+
+    if (a.no_host_config_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_host_config_, a.no_host_config_);
+    }
+
+    if (a.build2_config_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->build2_config_, a.build2_config_);
+      this->build2_config_specified_ = true;
+    }
+
+    if (a.no_build2_config_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_build2_config_, a.no_build2_config_);
+    }
+
+    if (a.name_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->name_, a.name_);
+      this->name_specified_ = true;
+    }
+
+    if (a.type_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->type_, a.type_);
+      this->type_specified_ = true;
+    }
+
+    if (a.uuid_specified_)
+    {
+      ::bpkg::cli::parser< uuid_type>::merge (
+        this->uuid_, a.uuid_);
+      this->uuid_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para cfg_create_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mCFG-CREATE OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--directory\033[0m|\033[1m-d\033[0m \033[4mdir\033[0m        Create the configuration in \033[4mdir\033[0m rather than in the" << ::std::endl
+       << "                          current working directory." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--existing\033[0m|\033[1m-e\033[0m             Initialize a \033[1mbpkg\033[0m configuration based on an existing" << ::std::endl
+       << "                          build system configuration." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--wipe\033[0m                    Wipe the configuration directory clean before" << ::std::endl
+       << "                          creating the new configuration. For safety, this" << ::std::endl
+       << "                          option requires that you specify the configuration" << ::std::endl
+       << "                          directory explicitly with \033[1m--directory|-d\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--host-config\033[0m \033[4mdir\033[0m         Link the specified host configuration with the" << ::std::endl
+       << "                          configuration being created as if by running the" << ::std::endl
+       << "                          \033[1mbpkg-cfg-link(1)\033[0m command." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-host-config\033[0m          Ignore any specified \033[1m--host-config\033[0m options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--build2-config\033[0m \033[4mdir\033[0m       Link the specified build system module configuration" << ::std::endl
+       << "                          with the configuration being created as if by running" << ::std::endl
+       << "                          the \033[1mbpkg-cfg-link(1)\033[0m command." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-build2-config\033[0m        Ignore any specified \033[1m--build2-config\033[0m options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--name\033[0m \033[4mname\033[0m               The name of the configuration being created. If this" << ::std::endl
+       << "                          configuration is linked with another configuration" << ::std::endl
+       << "                          using \033[1mbpkg-cfg-link(1)\033[0m, this name will be used as the" << ::std::endl
+       << "                          link name unless overridden. By default the" << ::std::endl
+       << "                          configuration is created unnamed." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--type\033[0m \033[4mtype\033[0m               The type of the configuration being created. By" << ::std::endl
+       << "                          default, configuration of type \033[1mtarget\033[0m is created." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--uuid\033[0m \033[4muuid\033[0m               Use the specified UUID as the configuration id" << ::std::endl
+       << "                          instead of generating one automatically." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (cfg_create_options&, ::bpkg::cli::scanner&)>
+  _cli_cfg_create_options_map;
+
+  static _cli_cfg_create_options_map _cli_cfg_create_options_map_;
+
+  struct _cli_cfg_create_options_map_init
+  {
+    _cli_cfg_create_options_map_init ()
+    {
+      _cli_cfg_create_options_map_["--directory"] =
+      &::bpkg::cli::thunk< cfg_create_options, dir_path, &cfg_create_options::directory_,
+        &cfg_create_options::directory_specified_ >;
+      _cli_cfg_create_options_map_["-d"] =
+      &::bpkg::cli::thunk< cfg_create_options, dir_path, &cfg_create_options::directory_,
+        &cfg_create_options::directory_specified_ >;
+      _cli_cfg_create_options_map_["--existing"] =
+      &::bpkg::cli::thunk< cfg_create_options, &cfg_create_options::existing_ >;
+      _cli_cfg_create_options_map_["-e"] =
+      &::bpkg::cli::thunk< cfg_create_options, &cfg_create_options::existing_ >;
+      _cli_cfg_create_options_map_["--wipe"] =
+      &::bpkg::cli::thunk< cfg_create_options, &cfg_create_options::wipe_ >;
+      _cli_cfg_create_options_map_["--host-config"] =
+      &::bpkg::cli::thunk< cfg_create_options, dir_path, &cfg_create_options::host_config_,
+        &cfg_create_options::host_config_specified_ >;
+      _cli_cfg_create_options_map_["--no-host-config"] =
+      &::bpkg::cli::thunk< cfg_create_options, &cfg_create_options::no_host_config_ >;
+      _cli_cfg_create_options_map_["--build2-config"] =
+      &::bpkg::cli::thunk< cfg_create_options, dir_path, &cfg_create_options::build2_config_,
+        &cfg_create_options::build2_config_specified_ >;
+      _cli_cfg_create_options_map_["--no-build2-config"] =
+      &::bpkg::cli::thunk< cfg_create_options, &cfg_create_options::no_build2_config_ >;
+      _cli_cfg_create_options_map_["--name"] =
+      &::bpkg::cli::thunk< cfg_create_options, string, &cfg_create_options::name_,
+        &cfg_create_options::name_specified_ >;
+      _cli_cfg_create_options_map_["--type"] =
+      &::bpkg::cli::thunk< cfg_create_options, string, &cfg_create_options::type_,
+        &cfg_create_options::type_specified_ >;
+      _cli_cfg_create_options_map_["--uuid"] =
+      &::bpkg::cli::thunk< cfg_create_options, uuid_type, &cfg_create_options::uuid_,
+        &cfg_create_options::uuid_specified_ >;
+    }
+  };
+
+  static _cli_cfg_create_options_map_init _cli_cfg_create_options_map_init_;
+
+  bool cfg_create_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_cfg_create_options_map::const_iterator i (_cli_cfg_create_options_map_.find (o));
+
+    if (i != _cli_cfg_create_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool cfg_create_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_create_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg cfg-create\033[0m|\033[1mcreate\033[0m [\033[4moptions\033[0m] [\033[4mcfg-args\033[0m]" << ::std::endl
+       << "\033[1mbpkg cfg-create\033[0m|\033[1mcreate\033[0m [\033[4moptions\033[0m] \033[1m--existing|-e\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[4mcfg-args\033[0m = (\033[4mmodule\033[0m | \033[4mcfg-var\033[0m)...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mcfg-create\033[0m command creates a new \033[1mbpkg\033[0m configuration with the specified" << ::std::endl
+       << "\033[1mbuild2\033[0m modules and configuration variables (the first form) or initializes one" << ::std::endl
+       << "based on an existing build system configuration (the second form). The \033[1mbpkg\033[0m" << ::std::endl
+       << "configuration itself is a build system configuration; see build system driver" << ::std::endl
+       << "(\033[1mb(1)\033[0m) \033[1mcreate\033[0m meta-operation for details." << ::std::endl
+       << ::std::endl
+       << "Unless the \033[1m--existing|-e\033[0m or \033[1m--wipe\033[0m option is specified, \033[1mcfg-create\033[0m expects the" << ::std::endl
+       << "configuration directory to be empty or to not exist (in which case it will be" << ::std::endl
+       << "created)." << ::std::endl
+       << ::std::endl
+       << "By default, the configuration created with the first form loads the \033[1mconfig\033[0m," << ::std::endl
+       << "\033[1mtest\033[0m, \033[1mdist\033[0m, and \033[1minstall\033[0m modules. However, additional modules and, if required," << ::std::endl
+       << "their configuration variables can be specified as the \033[1mcfg-create\033[0m arguments. For" << ::std::endl
+       << "example:" << ::std::endl
+       << ::std::endl
+       << "bpkg create cxx config.cxx=clang++ config.install.root=/usr/local" << ::std::endl
+       << ::std::endl
+       << "By default, \033[1mbpkg\033[0m appends \033[1m.config\033[0m to the names of the modules that you specify" << ::std::endl
+       << "so that only their configurations are loaded. You can override this behavior by" << ::std::endl
+       << "specifying the period (\033[1m.\033[0m) after the module name. You can also instruct \033[1mbpkg\033[0m to" << ::std::endl
+       << "use the optional module load by prefixing the module name with the question" << ::std::endl
+       << "mark (\033[1m?\033[0m). For example:" << ::std::endl
+       << ::std::endl
+       << "bpkg create cxx. \"?cli\"" << ::std::endl
+       << ::std::endl
+       << "Configurations can be linked with each other to allow a package to be built in" << ::std::endl
+       << "one configuration while its dependencies in one or more linked configurations." << ::std::endl
+       << "This can be used to create a \"base\" configuration with common dependencies that" << ::std::endl
+       << "are shared between multiple configurations. This mechanism is also used to" << ::std::endl
+       << "provide a host configuration that is used to build build-time dependencies." << ::std::endl
+       << ::std::endl
+       << "Each configuration is assigned an automatically-generated UUID unless one is" << ::std::endl
+       << "specified with the \033[1m--uuid\033[0m option. This UUID is used to check the integrity of" << ::std::endl
+       << "configuration links. For convenience of referring to linked configurations, a" << ::std::endl
+       << "configuration can also be assigned a name with the \033[1m--name\033[0m option." << ::std::endl
+       << ::std::endl
+       << "A configuration also has a type specified with the \033[1m--type\033[0m option. Three" << ::std::endl
+       << "predefined types are \033[1mtarget\033[0m, \033[1mhost\033[0m, and \033[1mbuild2\033[0m. If the type is not specified" << ::std::endl
+       << "explicitly, then \033[1mtarget\033[0m is assumed. When satisfying a dependency of one package" << ::std::endl
+       << "on another, a linked configuration will only be considered if (1) it has the" << ::std::endl
+       << "same type as the other configuration for run-time dependencies, (2) it has the" << ::std::endl
+       << "\033[1mhost\033[0m type for regular build-time dependencies, and (3) it has the \033[1mbuild2\033[0m type" << ::std::endl
+       << "for build system module build-time dependencies. Note that a host configuration" << ::std::endl
+       << "is a target configuration for the host machine. So to create a self-hosted" << ::std::endl
+       << "configuration, use type \033[1mhost\033[0m." << ::std::endl
+       << ::std::endl
+       << "To link a configuration we use the \033[1mbpkg-cfg-link(1)\033[0m command. As a shortcut," << ::std::endl
+       << "host and build system module configurations can also be linked during the" << ::std::endl
+       << "configuration creation with the \033[1m--host-config\033[0m and \033[1m--build2-config\033[0m options," << ::std::endl
+       << "respectively. If a build-time dependency is encountered in a configuration that" << ::std::endl
+       << "has no linked configuration of a suitable type (\033[1mhost\033[0m or \033[1mbuild2\033[0m, nor is itself" << ::std::endl
+       << "of a suitable type), then a private host or build system module configuration" << ::std::endl
+       << "named \033[1mhost\033[0m or \033[1mbuild2\033[0m, respectively, is created automatically inside the" << ::std::endl
+       << "configuration's .bpkg/\033[0m subdirectory." << ::std::endl;
+
+    p = ::bpkg::cfg_create_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mcfg-create\033[0m command the search start directory is the parent directory" << ::std::endl
+       << "of the new configuration. The following options files are searched for in each" << ::std::endl
+       << "directory and, if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-cfg-create.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mcfg-create\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl
+       << "--wipe" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/cfg-create-options.hxx b/bpkg/cfg-create-options.hxx
new file mode 100644
index 0000000..f47594d
--- /dev/null
+++ b/bpkg/cfg-create-options.hxx
@@ -0,0 +1,173 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_CFG_CREATE_OPTIONS_HXX
+#define BPKG_CFG_CREATE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class cfg_create_options: public ::bpkg::common_options
+  {
+    public:
+    cfg_create_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const cfg_create_options&);
+
+    // Option accessors.
+    //
+    const dir_path&
+    directory () const;
+
+    bool
+    directory_specified () const;
+
+    const bool&
+    existing () const;
+
+    const bool&
+    wipe () const;
+
+    const dir_path&
+    host_config () const;
+
+    bool
+    host_config_specified () const;
+
+    const bool&
+    no_host_config () const;
+
+    const dir_path&
+    build2_config () const;
+
+    bool
+    build2_config_specified () const;
+
+    const bool&
+    no_build2_config () const;
+
+    const string&
+    name () const;
+
+    bool
+    name_specified () const;
+
+    const string&
+    type () const;
+
+    bool
+    type_specified () const;
+
+    const uuid_type&
+    uuid () const;
+
+    bool
+    uuid_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    dir_path directory_;
+    bool directory_specified_;
+    bool existing_;
+    bool wipe_;
+    dir_path host_config_;
+    bool host_config_specified_;
+    bool no_host_config_;
+    dir_path build2_config_;
+    bool build2_config_specified_;
+    bool no_build2_config_;
+    string name_;
+    bool name_specified_;
+    string type_;
+    bool type_specified_;
+    uuid_type uuid_;
+    bool uuid_specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_create_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/cfg-create-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_CFG_CREATE_OPTIONS_HXX
diff --git a/bpkg/cfg-create-options.ixx b/bpkg/cfg-create-options.ixx
new file mode 100644
index 0000000..9e8b1f6
--- /dev/null
+++ b/bpkg/cfg-create-options.ixx
@@ -0,0 +1,117 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // cfg_create_options
+  //
+
+  inline const dir_path& cfg_create_options::
+  directory () const
+  {
+    return this->directory_;
+  }
+
+  inline bool cfg_create_options::
+  directory_specified () const
+  {
+    return this->directory_specified_;
+  }
+
+  inline const bool& cfg_create_options::
+  existing () const
+  {
+    return this->existing_;
+  }
+
+  inline const bool& cfg_create_options::
+  wipe () const
+  {
+    return this->wipe_;
+  }
+
+  inline const dir_path& cfg_create_options::
+  host_config () const
+  {
+    return this->host_config_;
+  }
+
+  inline bool cfg_create_options::
+  host_config_specified () const
+  {
+    return this->host_config_specified_;
+  }
+
+  inline const bool& cfg_create_options::
+  no_host_config () const
+  {
+    return this->no_host_config_;
+  }
+
+  inline const dir_path& cfg_create_options::
+  build2_config () const
+  {
+    return this->build2_config_;
+  }
+
+  inline bool cfg_create_options::
+  build2_config_specified () const
+  {
+    return this->build2_config_specified_;
+  }
+
+  inline const bool& cfg_create_options::
+  no_build2_config () const
+  {
+    return this->no_build2_config_;
+  }
+
+  inline const string& cfg_create_options::
+  name () const
+  {
+    return this->name_;
+  }
+
+  inline bool cfg_create_options::
+  name_specified () const
+  {
+    return this->name_specified_;
+  }
+
+  inline const string& cfg_create_options::
+  type () const
+  {
+    return this->type_;
+  }
+
+  inline bool cfg_create_options::
+  type_specified () const
+  {
+    return this->type_specified_;
+  }
+
+  inline const uuid_type& cfg_create_options::
+  uuid () const
+  {
+    return this->uuid_;
+  }
+
+  inline bool cfg_create_options::
+  uuid_specified () const
+  {
+    return this->uuid_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/cfg-info-options.cxx b/bpkg/cfg-info-options.cxx
new file mode 100644
index 0000000..51758f4
--- /dev/null
+++ b/bpkg/cfg-info-options.cxx
@@ -0,0 +1,745 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/cfg-info-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // cfg_info_options
+  //
+
+  cfg_info_options::
+  cfg_info_options ()
+  : link_ (),
+    backlink_ (),
+    dangling_ (),
+    recursive_ ()
+  {
+  }
+
+  bool cfg_info_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_info_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_info_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_info_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_info_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void cfg_info_options::
+  merge (const cfg_info_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.link_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->link_, a.link_);
+    }
+
+    if (a.backlink_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->backlink_, a.backlink_);
+    }
+
+    if (a.dangling_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->dangling_, a.dangling_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+  }
+
+  ::bpkg::cli::usage_para cfg_info_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mCFG-INFO OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--link\033[0m                    Print linked configurations." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--backlink\033[0m                Print implicitly backlinked configurations." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--dangling\033[0m                Print dangling implicit backlinks." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m               Print linked configurations recursively." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (cfg_info_options&, ::bpkg::cli::scanner&)>
+  _cli_cfg_info_options_map;
+
+  static _cli_cfg_info_options_map _cli_cfg_info_options_map_;
+
+  struct _cli_cfg_info_options_map_init
+  {
+    _cli_cfg_info_options_map_init ()
+    {
+      _cli_cfg_info_options_map_["--link"] =
+      &::bpkg::cli::thunk< cfg_info_options, &cfg_info_options::link_ >;
+      _cli_cfg_info_options_map_["--backlink"] =
+      &::bpkg::cli::thunk< cfg_info_options, &cfg_info_options::backlink_ >;
+      _cli_cfg_info_options_map_["--dangling"] =
+      &::bpkg::cli::thunk< cfg_info_options, &cfg_info_options::dangling_ >;
+      _cli_cfg_info_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< cfg_info_options, &cfg_info_options::recursive_ >;
+    }
+  };
+
+  static _cli_cfg_info_options_map_init _cli_cfg_info_options_map_init_;
+
+  bool cfg_info_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_cfg_info_options_map::const_iterator i (_cli_cfg_info_options_map_.find (o));
+
+    if (i != _cli_cfg_info_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool cfg_info_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_info_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg cfg-info\033[0m [\033[4moptions\033[0m]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mcfg-info\033[0m command prints the current configuration's absolute path, id," << ::std::endl
+       << "type, and name. If the \033[1m--link\033[0m and/or \033[1m--backlink\033[0m options are specified, then" << ::std::endl
+       << "this information is also printed for each linked and/or implicitly backlinked" << ::std::endl
+       << "configuration, if any. Note that the dangling implicit backlinks are silently" << ::std::endl
+       << "skipped, unless \033[1m--dangling\033[0m is specified, in which case this information is also" << ::std::endl
+       << "printed for them. Note that the information is written to \033[1mstdout\033[0m, not \033[1mstderr\033[0m." << ::std::endl
+       << ::std::endl
+       << "If the \033[1m--recursive\033[0m option is specified together with \033[1m--link\033[0m and/or \033[1m--backlink\033[0m," << ::std::endl
+       << "then this information is printed for linked and/or implicitly backlinked" << ::std::endl
+       << "configuration, recursively." << ::std::endl
+       << ::std::endl
+       << "The output format is regular with each value printed on a separate line and" << ::std::endl
+       << "prefixed with the value name. If the \033[1m--link\033[0m, \033[1m--backlink\033[0m, and/or \033[1m--dangling\033[0m" << ::std::endl
+       << "options are specified, then information blocks corresponding to linked" << ::std::endl
+       << "configurations are separated with blank lines. For example:" << ::std::endl
+       << ::std::endl
+       << "path: /path/to/cfg/" << ::std::endl
+       << "uuid: 8d439f03-7342-4502-8b1c-74b173869478" << ::std::endl
+       << "type: target" << ::std::endl
+       << "name: foo" << ::std::endl
+       << ::std::endl
+       << "path: /path/to/host-cfg/" << ::std::endl
+       << "uuid: 7ee4dab3-07d9-4163-81c0-3779166a7213" << ::std::endl
+       << "type: host" << ::std::endl
+       << "name: tools" << ::std::endl
+       << ::std::endl
+       << "path: /path/to/build2-cfg/" << ::std::endl
+       << "uuid: d453aa2a-92c4-4066-87e4-c8672eed06e1" << ::std::endl
+       << "type: build2" << ::std::endl
+       << "name: modules" << ::std::endl;
+
+    p = ::bpkg::cfg_info_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mcfg-info\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-cfg-info.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mcfg-info\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/cfg-info-options.hxx b/bpkg/cfg-info-options.hxx
new file mode 100644
index 0000000..2024bf6
--- /dev/null
+++ b/bpkg/cfg-info-options.hxx
@@ -0,0 +1,125 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_CFG_INFO_OPTIONS_HXX
+#define BPKG_CFG_INFO_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class cfg_info_options: public ::bpkg::configuration_options
+  {
+    public:
+    cfg_info_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const cfg_info_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    link () const;
+
+    const bool&
+    backlink () const;
+
+    const bool&
+    dangling () const;
+
+    const bool&
+    recursive () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool link_;
+    bool backlink_;
+    bool dangling_;
+    bool recursive_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_info_usage (::std::ostream&,
+                             ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/cfg-info-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_CFG_INFO_OPTIONS_HXX
diff --git a/bpkg/cfg-info-options.ixx b/bpkg/cfg-info-options.ixx
new file mode 100644
index 0000000..3eb43b3
--- /dev/null
+++ b/bpkg/cfg-info-options.ixx
@@ -0,0 +1,45 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // cfg_info_options
+  //
+
+  inline const bool& cfg_info_options::
+  link () const
+  {
+    return this->link_;
+  }
+
+  inline const bool& cfg_info_options::
+  backlink () const
+  {
+    return this->backlink_;
+  }
+
+  inline const bool& cfg_info_options::
+  dangling () const
+  {
+    return this->dangling_;
+  }
+
+  inline const bool& cfg_info_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/cfg-link-options.cxx b/bpkg/cfg-link-options.cxx
new file mode 100644
index 0000000..6479d14
--- /dev/null
+++ b/bpkg/cfg-link-options.cxx
@@ -0,0 +1,715 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/cfg-link-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // cfg_link_options
+  //
+
+  cfg_link_options::
+  cfg_link_options ()
+  : name_ (),
+    name_specified_ (false),
+    relative_ ()
+  {
+  }
+
+  bool cfg_link_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_link_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_link_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_link_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_link_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void cfg_link_options::
+  merge (const cfg_link_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.name_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->name_, a.name_);
+      this->name_specified_ = true;
+    }
+
+    if (a.relative_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->relative_, a.relative_);
+    }
+  }
+
+  ::bpkg::cli::usage_para cfg_link_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mCFG-LINK OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--name\033[0m \033[4mname\033[0m               Alternative link name. If this option is not" << ::std::endl
+       << "                          specified, then the configuration name is used as the" << ::std::endl
+       << "                          link name (see \033[1mbpkg-cfg-create(1)\033[0m for details)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--relative\033[0m                Rebase the absolute linked configuration path" << ::std::endl
+       << "                          relative to the current configuration directory." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (cfg_link_options&, ::bpkg::cli::scanner&)>
+  _cli_cfg_link_options_map;
+
+  static _cli_cfg_link_options_map _cli_cfg_link_options_map_;
+
+  struct _cli_cfg_link_options_map_init
+  {
+    _cli_cfg_link_options_map_init ()
+    {
+      _cli_cfg_link_options_map_["--name"] =
+      &::bpkg::cli::thunk< cfg_link_options, string, &cfg_link_options::name_,
+        &cfg_link_options::name_specified_ >;
+      _cli_cfg_link_options_map_["--relative"] =
+      &::bpkg::cli::thunk< cfg_link_options, &cfg_link_options::relative_ >;
+    }
+  };
+
+  static _cli_cfg_link_options_map_init _cli_cfg_link_options_map_init_;
+
+  bool cfg_link_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_cfg_link_options_map::const_iterator i (_cli_cfg_link_options_map_.find (o));
+
+    if (i != _cli_cfg_link_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool cfg_link_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_link_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg cfg-link\033[0m [\033[4moptions\033[0m] \033[4mdir\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mcfg-link\033[0m command links the specified \033[1mbpkg\033[0m configuration with the current" << ::std::endl
+       << "configuration. Note that it also establishes an implicit backlink from the" << ::std::endl
+       << "specified to the current configuration. See \033[1mbpkg-cfg-create(1)\033[0m for background" << ::std::endl
+       << "on linked configurations. To unlink previously linked configurations use" << ::std::endl
+       << "\033[1mbpkg-cfg-unlink(1)\033[0m." << ::std::endl
+       << ::std::endl
+       << "The linked configurations are normally referred to using names when specified" << ::std::endl
+       << "on the \033[1mbpkg\033[0m command line. Unless overridden with the \033[1m--name\033[0m option, the" << ::std::endl
+       << "original configuration name is used to name the link. If the link is unnamed," << ::std::endl
+       << "then it can be referred to using the numeric id that is automatically assigned" << ::std::endl
+       << "when establishing the link or using the configuration UUID." << ::std::endl
+       << ::std::endl
+       << "If the specified configuration path is relative, then it is rebased relative to" << ::std::endl
+       << "the current configuration directory. This way, when the linked configurations" << ::std::endl
+       << "are moved around together, the stored relative paths remain valid. If the" << ::std::endl
+       << "specified directory path is absolute, then it is stored as absolute unless the" << ::std::endl
+       << "\033[1m--relative\033[0m option is specified in which case it is also rebased relative to the" << ::std::endl
+       << "current configuration directory." << ::std::endl;
+
+    p = ::bpkg::cfg_link_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mcfg-link\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-cfg-link.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mcfg-link\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/cfg-link-options.hxx b/bpkg/cfg-link-options.hxx
new file mode 100644
index 0000000..9c506ce
--- /dev/null
+++ b/bpkg/cfg-link-options.hxx
@@ -0,0 +1,121 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_CFG_LINK_OPTIONS_HXX
+#define BPKG_CFG_LINK_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class cfg_link_options: public ::bpkg::configuration_options
+  {
+    public:
+    cfg_link_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const cfg_link_options&);
+
+    // Option accessors.
+    //
+    const string&
+    name () const;
+
+    bool
+    name_specified () const;
+
+    const bool&
+    relative () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    string name_;
+    bool name_specified_;
+    bool relative_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_link_usage (::std::ostream&,
+                             ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/cfg-link-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_CFG_LINK_OPTIONS_HXX
diff --git a/bpkg/cfg-link-options.ixx b/bpkg/cfg-link-options.ixx
new file mode 100644
index 0000000..685f89e
--- /dev/null
+++ b/bpkg/cfg-link-options.ixx
@@ -0,0 +1,39 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // cfg_link_options
+  //
+
+  inline const string& cfg_link_options::
+  name () const
+  {
+    return this->name_;
+  }
+
+  inline bool cfg_link_options::
+  name_specified () const
+  {
+    return this->name_specified_;
+  }
+
+  inline const bool& cfg_link_options::
+  relative () const
+  {
+    return this->relative_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/cfg-unlink-options.cxx b/bpkg/cfg-unlink-options.cxx
new file mode 100644
index 0000000..82b08d6
--- /dev/null
+++ b/bpkg/cfg-unlink-options.cxx
@@ -0,0 +1,732 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/cfg-unlink-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // cfg_unlink_options
+  //
+
+  cfg_unlink_options::
+  cfg_unlink_options ()
+  : name_ (),
+    name_specified_ (false),
+    id_ (),
+    id_specified_ (false),
+    uuid_ (),
+    uuid_specified_ (false),
+    dangling_ ()
+  {
+  }
+
+  bool cfg_unlink_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_unlink_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool cfg_unlink_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_unlink_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool cfg_unlink_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void cfg_unlink_options::
+  merge (const cfg_unlink_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.name_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->name_, a.name_);
+      this->name_specified_ = true;
+    }
+
+    if (a.id_specified_)
+    {
+      ::bpkg::cli::parser< uint64_t>::merge (
+        this->id_, a.id_);
+      this->id_specified_ = true;
+    }
+
+    if (a.uuid_specified_)
+    {
+      ::bpkg::cli::parser< uuid_type>::merge (
+        this->uuid_, a.uuid_);
+      this->uuid_specified_ = true;
+    }
+
+    if (a.dangling_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->dangling_, a.dangling_);
+    }
+  }
+
+  ::bpkg::cli::usage_para cfg_unlink_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mCFG-UNLINK OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--name\033[0m \033[4mname\033[0m               Name of the configuration to unlink." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--id\033[0m \033[4mid\033[0m                   Numeric id of the configuration to unlink." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--uuid\033[0m \033[4muuid\033[0m               UUID of the configuration to unlink." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--dangling\033[0m                Remove dangling implicit backlinks." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (cfg_unlink_options&, ::bpkg::cli::scanner&)>
+  _cli_cfg_unlink_options_map;
+
+  static _cli_cfg_unlink_options_map _cli_cfg_unlink_options_map_;
+
+  struct _cli_cfg_unlink_options_map_init
+  {
+    _cli_cfg_unlink_options_map_init ()
+    {
+      _cli_cfg_unlink_options_map_["--name"] =
+      &::bpkg::cli::thunk< cfg_unlink_options, string, &cfg_unlink_options::name_,
+        &cfg_unlink_options::name_specified_ >;
+      _cli_cfg_unlink_options_map_["--id"] =
+      &::bpkg::cli::thunk< cfg_unlink_options, uint64_t, &cfg_unlink_options::id_,
+        &cfg_unlink_options::id_specified_ >;
+      _cli_cfg_unlink_options_map_["--uuid"] =
+      &::bpkg::cli::thunk< cfg_unlink_options, uuid_type, &cfg_unlink_options::uuid_,
+        &cfg_unlink_options::uuid_specified_ >;
+      _cli_cfg_unlink_options_map_["--dangling"] =
+      &::bpkg::cli::thunk< cfg_unlink_options, &cfg_unlink_options::dangling_ >;
+    }
+  };
+
+  static _cli_cfg_unlink_options_map_init _cli_cfg_unlink_options_map_init_;
+
+  bool cfg_unlink_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_cfg_unlink_options_map::const_iterator i (_cli_cfg_unlink_options_map_.find (o));
+
+    if (i != _cli_cfg_unlink_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool cfg_unlink_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_unlink_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg cfg-unlink\033[0m [\033[4moptions\033[0m] [\033[4mdir\033[0m]" << ::std::endl
+       << "\033[1mbpkg cfg-unlink\033[0m [\033[4moptions\033[0m] \033[1m--dangling\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mcfg-unlink\033[0m command unlinks the specified \033[1mbpkg\033[0m configuration from the" << ::std::endl
+       << "current configuration (the first form) or removes dangling implicit backlinks" << ::std::endl
+       << "(the second form). See \033[1mbpkg-cfg-create(1)\033[0m for background on linked" << ::std::endl
+       << "configurations." << ::std::endl
+       << ::std::endl
+       << "In the first form the configuration to unlink can be specified either as" << ::std::endl
+       << "configuration directory (\033[4mdir\033[0m), name (\033[1m--name\033[0m), id (\033[1m--id\033[0m), or UUID (\033[1m--uuid\033[0m)." << ::std::endl;
+
+    p = ::bpkg::cfg_unlink_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mcfg-unlink\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-cfg-unlink.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mcfg-unlink\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/cfg-unlink-options.hxx b/bpkg/cfg-unlink-options.hxx
new file mode 100644
index 0000000..14c9aa4
--- /dev/null
+++ b/bpkg/cfg-unlink-options.hxx
@@ -0,0 +1,137 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_CFG_UNLINK_OPTIONS_HXX
+#define BPKG_CFG_UNLINK_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class cfg_unlink_options: public ::bpkg::configuration_options
+  {
+    public:
+    cfg_unlink_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const cfg_unlink_options&);
+
+    // Option accessors.
+    //
+    const string&
+    name () const;
+
+    bool
+    name_specified () const;
+
+    const uint64_t&
+    id () const;
+
+    bool
+    id_specified () const;
+
+    const uuid_type&
+    uuid () const;
+
+    bool
+    uuid_specified () const;
+
+    const bool&
+    dangling () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    string name_;
+    bool name_specified_;
+    uint64_t id_;
+    bool id_specified_;
+    uuid_type uuid_;
+    bool uuid_specified_;
+    bool dangling_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_cfg_unlink_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/cfg-unlink-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_CFG_UNLINK_OPTIONS_HXX
diff --git a/bpkg/cfg-unlink-options.ixx b/bpkg/cfg-unlink-options.ixx
new file mode 100644
index 0000000..7d9d63c
--- /dev/null
+++ b/bpkg/cfg-unlink-options.ixx
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // cfg_unlink_options
+  //
+
+  inline const string& cfg_unlink_options::
+  name () const
+  {
+    return this->name_;
+  }
+
+  inline bool cfg_unlink_options::
+  name_specified () const
+  {
+    return this->name_specified_;
+  }
+
+  inline const uint64_t& cfg_unlink_options::
+  id () const
+  {
+    return this->id_;
+  }
+
+  inline bool cfg_unlink_options::
+  id_specified () const
+  {
+    return this->id_specified_;
+  }
+
+  inline const uuid_type& cfg_unlink_options::
+  uuid () const
+  {
+    return this->uuid_;
+  }
+
+  inline bool cfg_unlink_options::
+  uuid_specified () const
+  {
+    return this->uuid_specified_;
+  }
+
+  inline const bool& cfg_unlink_options::
+  dangling () const
+  {
+    return this->dangling_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/common-options.cxx b/bpkg/common-options.cxx
new file mode 100644
index 0000000..e841232
--- /dev/null
+++ b/bpkg/common-options.cxx
@@ -0,0 +1,2230 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+#include <fstream>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    // unknown_option
+    //
+    unknown_option::
+    ~unknown_option () noexcept
+    {
+    }
+
+    void unknown_option::
+    print (::std::ostream& os) const
+    {
+      os << "unknown option '" << option ().c_str () << "'";
+    }
+
+    const char* unknown_option::
+    what () const noexcept
+    {
+      return "unknown option";
+    }
+
+    // unknown_argument
+    //
+    unknown_argument::
+    ~unknown_argument () noexcept
+    {
+    }
+
+    void unknown_argument::
+    print (::std::ostream& os) const
+    {
+      os << "unknown argument '" << argument ().c_str () << "'";
+    }
+
+    const char* unknown_argument::
+    what () const noexcept
+    {
+      return "unknown argument";
+    }
+
+    // missing_value
+    //
+    missing_value::
+    ~missing_value () noexcept
+    {
+    }
+
+    void missing_value::
+    print (::std::ostream& os) const
+    {
+      os << "missing value for option '" << option ().c_str () << "'";
+    }
+
+    const char* missing_value::
+    what () const noexcept
+    {
+      return "missing option value";
+    }
+
+    // invalid_value
+    //
+    invalid_value::
+    ~invalid_value () noexcept
+    {
+    }
+
+    void invalid_value::
+    print (::std::ostream& os) const
+    {
+      os << "invalid value '" << value ().c_str () << "' for option '"
+         << option ().c_str () << "'";
+
+      if (!message ().empty ())
+        os << ": " << message ().c_str ();
+    }
+
+    const char* invalid_value::
+    what () const noexcept
+    {
+      return "invalid option value";
+    }
+
+    // eos_reached
+    //
+    void eos_reached::
+    print (::std::ostream& os) const
+    {
+      os << what ();
+    }
+
+    const char* eos_reached::
+    what () const noexcept
+    {
+      return "end of argument stream reached";
+    }
+
+    // file_io_failure
+    //
+    file_io_failure::
+    ~file_io_failure () noexcept
+    {
+    }
+
+    void file_io_failure::
+    print (::std::ostream& os) const
+    {
+      os << "unable to open file '" << file ().c_str () << "' or read failure";
+    }
+
+    const char* file_io_failure::
+    what () const noexcept
+    {
+      return "unable to open file or read failure";
+    }
+
+    // unmatched_quote
+    //
+    unmatched_quote::
+    ~unmatched_quote () noexcept
+    {
+    }
+
+    void unmatched_quote::
+    print (::std::ostream& os) const
+    {
+      os << "unmatched quote in argument '" << argument ().c_str () << "'";
+    }
+
+    const char* unmatched_quote::
+    what () const noexcept
+    {
+      return "unmatched quote";
+    }
+
+    // unexpected_group
+    //
+    unexpected_group::
+    ~unexpected_group () noexcept
+    {
+    }
+
+    void unexpected_group::
+    print (::std::ostream& os) const
+    {
+      os << "unexpected grouped argument '" << group_ << "' "
+         << "for argument '" << argument_ << "'";
+    }
+
+    const char* unexpected_group::
+    what () const noexcept
+    {
+      return "unexpected grouped argument";
+    }
+
+    // group_separator
+    //
+    group_separator::
+    ~group_separator () noexcept
+    {
+    }
+
+    void group_separator::
+    print (::std::ostream& os) const
+    {
+      bool ex (!expected_.empty ());
+      bool en (!encountered_.empty ());
+
+      if (ex)
+      {
+        os << "expected group separator '" << expected_ << "'";
+        if (en)
+          os << " instead of '" << encountered_ << "'";
+      }
+      else
+        os << "unexpected group separator '" << encountered_ << "'";
+
+      if (en)
+        os << ", use '\\" << encountered_ << "' to escape";
+    }
+
+    const char* group_separator::
+    what () const noexcept
+    {
+      bool ex (!expected_.empty ());
+      bool en (!encountered_.empty ());
+
+      return en
+        ? ex ? "wrong group separator"    : "unexpected group separator"
+        : ex ? "expected group separator" : "";
+    }
+
+    // scanner
+    //
+    scanner::
+    ~scanner ()
+    {
+    }
+
+    // argv_scanner
+    //
+    bool argv_scanner::
+    more ()
+    {
+      return i_ < argc_;
+    }
+
+    const char* argv_scanner::
+    peek ()
+    {
+      if (i_ < argc_)
+        return argv_[i_];
+      else
+        throw eos_reached ();
+    }
+
+    const char* argv_scanner::
+    next ()
+    {
+      if (i_ < argc_)
+      {
+        const char* r (argv_[i_]);
+
+        if (erase_)
+        {
+          for (int i (i_ + 1); i < argc_; ++i)
+            argv_[i - 1] = argv_[i];
+
+          --argc_;
+          argv_[argc_] = 0;
+        }
+        else
+          ++i_;
+
+        ++start_position_;
+        return r;
+      }
+      else
+        throw eos_reached ();
+    }
+
+    void argv_scanner::
+    skip ()
+    {
+      if (i_ < argc_)
+      {
+        ++i_;
+        ++start_position_;
+      }
+      else
+        throw eos_reached ();
+    }
+
+    std::size_t argv_scanner::
+    position ()
+    {
+      return start_position_;
+    }
+
+    // vector_scanner
+    //
+    bool vector_scanner::
+    more ()
+    {
+      return i_ < v_.size ();
+    }
+
+    const char* vector_scanner::
+    peek ()
+    {
+      if (i_ < v_.size ())
+        return v_[i_].c_str ();
+      else
+        throw eos_reached ();
+    }
+
+    const char* vector_scanner::
+    next ()
+    {
+      if (i_ < v_.size ())
+        return v_[i_++].c_str ();
+      else
+        throw eos_reached ();
+    }
+
+    void vector_scanner::
+    skip ()
+    {
+      if (i_ < v_.size ())
+        ++i_;
+      else
+        throw eos_reached ();
+    }
+
+    std::size_t vector_scanner::
+    position ()
+    {
+      return start_position_ + i_;
+    }
+
+    // argv_file_scanner
+    //
+    int argv_file_scanner::zero_argc_ = 0;
+    std::string argv_file_scanner::empty_string_;
+
+    bool argv_file_scanner::
+    more ()
+    {
+      if (!args_.empty ())
+        return true;
+
+      while (base::more ())
+      {
+        // See if the next argument is the file option.
+        //
+        const char* a (base::peek ());
+        const option_info* oi = 0;
+        const char* ov = 0;
+
+        if (!skip_)
+        {
+          if ((oi = find (a)) != 0)
+          {
+            base::next ();
+
+            if (!base::more ())
+              throw missing_value (a);
+
+            ov = base::next ();
+          }
+          else if (std::strncmp (a, "-", 1) == 0)
+          {
+            if ((ov = std::strchr (a, '=')) != 0)
+            {
+              std::string o (a, 0, ov - a);
+              if ((oi = find (o.c_str ())) != 0)
+              {
+                base::next ();
+                ++ov;
+              }
+            }
+          }
+        }
+
+        if (oi != 0)
+        {
+          if (oi->search_func != 0)
+          {
+            std::string f (oi->search_func (ov, oi->arg));
+
+            if (!f.empty ())
+              load (f);
+          }
+          else
+            load (ov);
+
+          if (!args_.empty ())
+            return true;
+        }
+        else
+        {
+          if (!skip_)
+            skip_ = (std::strcmp (a, "--") == 0);
+
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    const char* argv_file_scanner::
+    peek ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      return args_.empty () ? base::peek () : args_.front ().value.c_str ();
+    }
+
+    const std::string& argv_file_scanner::
+    peek_file ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      return args_.empty () ? empty_string_ : *args_.front ().file;
+    }
+
+    std::size_t argv_file_scanner::
+    peek_line ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      return args_.empty () ? 0 : args_.front ().line;
+    }
+
+    const char* argv_file_scanner::
+    next ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      if (args_.empty ())
+        return base::next ();
+      else
+      {
+        hold_[i_ == 0 ? ++i_ : --i_].swap (args_.front ().value);
+        args_.pop_front ();
+        ++start_position_;
+        return hold_[i_].c_str ();
+      }
+    }
+
+    void argv_file_scanner::
+    skip ()
+    {
+      if (!more ())
+        throw eos_reached ();
+
+      if (args_.empty ())
+        return base::skip ();
+      else
+      {
+        args_.pop_front ();
+        ++start_position_;
+      }
+    }
+
+    const argv_file_scanner::option_info* argv_file_scanner::
+    find (const char* a) const
+    {
+      for (std::size_t i (0); i < options_count_; ++i)
+        if (std::strcmp (a, options_[i].option) == 0)
+          return &options_[i];
+
+      return 0;
+    }
+
+    std::size_t argv_file_scanner::
+    position ()
+    {
+      return start_position_;
+    }
+
+    void argv_file_scanner::
+    load (const std::string& file)
+    {
+      using namespace std;
+
+      ifstream is (file.c_str ());
+
+      if (!is.is_open ())
+        throw file_io_failure (file);
+
+      files_.push_back (file);
+
+      arg a;
+      a.file = &*files_.rbegin ();
+
+      for (a.line = 1; !is.eof (); ++a.line)
+      {
+        string line;
+        getline (is, line);
+
+        if (is.fail () && !is.eof ())
+          throw file_io_failure (file);
+
+        string::size_type n (line.size ());
+
+        // Trim the line from leading and trailing whitespaces.
+        //
+        if (n != 0)
+        {
+          const char* f (line.c_str ());
+          const char* l (f + n);
+
+          const char* of (f);
+          while (f < l && (*f == ' ' || *f == '\t' || *f == '\r'))
+            ++f;
+
+          --l;
+
+          const char* ol (l);
+          while (l > f && (*l == ' ' || *l == '\t' || *l == '\r'))
+            --l;
+
+          if (f != of || l != ol)
+            line = f <= l ? string (f, l - f + 1) : string ();
+        }
+
+        // Ignore empty lines, those that start with #.
+        //
+        if (line.empty () || line[0] == '#')
+          continue;
+
+        string::size_type p (string::npos);
+        if (line.compare (0, 1, "-") == 0)
+        {
+          p = line.find (' ');
+
+          string::size_type q (line.find ('='));
+          if (q != string::npos && q < p)
+            p = q;
+        }
+
+        string s1;
+        if (p != string::npos)
+        {
+          s1.assign (line, 0, p);
+
+          // Skip leading whitespaces in the argument.
+          //
+          if (line[p] == '=')
+            ++p;
+          else
+          {
+            n = line.size ();
+            for (++p; p < n; ++p)
+            {
+              char c (line[p]);
+              if (c != ' ' && c != '\t' && c != '\r')
+                break;
+            }
+          }
+        }
+        else if (!skip_)
+          skip_ = (line == "--");
+
+        string s2 (line, p != string::npos ? p : 0);
+
+        // If the string (which is an option value or argument) is
+        // wrapped in quotes, remove them.
+        //
+        n = s2.size ();
+        char cf (s2[0]), cl (s2[n - 1]);
+
+        if (cf == '"' || cf == '\'' || cl == '"' || cl == '\'')
+        {
+          if (n == 1 || cf != cl)
+            throw unmatched_quote (s2);
+
+          s2 = string (s2, 1, n - 2);
+        }
+
+        if (!s1.empty ())
+        {
+          // See if this is another file option.
+          //
+          const option_info* oi;
+          if (!skip_ && (oi = find (s1.c_str ())))
+          {
+            if (s2.empty ())
+              throw missing_value (oi->option);
+
+            if (oi->search_func != 0)
+            {
+              string f (oi->search_func (s2.c_str (), oi->arg));
+              if (!f.empty ())
+                load (f);
+            }
+            else
+            {
+              // If the path of the file being parsed is not simple and the
+              // path of the file that needs to be loaded is relative, then
+              // complete the latter using the former as a base.
+              //
+#ifndef _WIN32
+              string::size_type p (file.find_last_of ('/'));
+              bool c (p != string::npos && s2[0] != '/');
+#else
+              string::size_type p (file.find_last_of ("/\\"));
+              bool c (p != string::npos && s2[1] != ':');
+#endif
+              if (c)
+                s2.insert (0, file, 0, p + 1);
+
+              load (s2);
+            }
+
+            continue;
+          }
+
+          a.value = s1;
+          args_.push_back (a);
+        }
+
+        a.value = s2;
+        args_.push_back (a);
+      }
+    }
+
+    // group_scanner
+    //
+    bool group_scanner::
+    more ()
+    {
+      // We don't want to call scan_group() here since that
+      // would invalidate references to previous arguments.
+      // But we do need to check that the previous group was
+      // handled.
+      //
+      if (state_ == scanned)
+      {
+        if (group_scan_.end () != group_.size ())
+          throw unexpected_group (arg_[i_][j_], group_scan_.next ());
+      }
+
+      return j_ != 0 || scan_.more ();
+    }
+
+    const char* group_scanner::
+    peek ()
+    {
+      if (state_ != peeked)
+      {
+        scan_group ();
+        state_ = peeked;
+      }
+
+      // Return unescaped.
+      return arg_[i_][j_ - 1].c_str ();
+    }
+
+    const char* group_scanner::
+    next ()
+    {
+      if (state_ != peeked)
+        scan_group ();
+      state_ = scanned;
+      // Return unescaped.
+      return arg_[i_][--j_].c_str ();
+    }
+
+    void group_scanner::
+    skip ()
+    {
+      if (state_ != peeked)
+        scan_group ();
+      state_ = skipped;
+      --j_;
+    }
+
+    std::size_t group_scanner::
+    position ()
+    {
+      return j_ == 0 ? scan_.position () : pos_ + (arg_[i_].size () - j_);
+    }
+
+    void group_scanner::
+    scan_group ()
+    {
+      // If the previous argument has been scanned, then make
+      // sure the group has been scanned (handled) as well.
+      //
+      if (state_ == scanned)
+      {
+        if (group_scan_.end () != group_.size ())
+          throw unexpected_group (arg_[i_][j_], group_scan_.next ());
+      }
+
+      // If we still have arguments in the pack, rewind the group.
+      //
+      if (j_ != 0)
+      {
+        group_scan_.reset ();
+        return;
+      }
+
+      i_ += (i_ == 0 ? 1 : -1);
+      group_.clear ();
+      group_scan_.reset ();
+      pos_ = scan_.position ();
+
+      // Note: using group_ won't cover empty groups and using
+      // j_ won't cover single-argument packs.
+      //
+      bool group (false), pack (false);
+
+      do
+      {
+        const char* a (scan_.next ());
+        size_t i (*a == '\\' ? 1 : 0);
+        separator s (sense (a + i));
+
+        if (s == none || i != 0)
+        {
+          if (arg_[i_].size () != 1)
+            arg_[i_].resize (1);
+
+          arg_[i_][0] = a + (s != none ? i : 0);
+          j_ = 1;
+          break;
+        }
+
+        // Start of a leading group for the next argument or
+        // argument pack. We will only know which once we see
+        // the closing separator.
+        //
+        if (s != open)
+          throw group_separator (a, "");
+
+        size_t n (group_.size ());
+
+        // Scan the group until the closing separator.
+        //
+        s = none;
+        while (s == none && scan_.more ())
+        {
+          a = scan_.next ();
+          i = (*a == '\\' ? 1 : 0);
+          s = sense (a + i);
+
+          if (s == none || i != 0)
+          {
+            group_.push_back (a + (s != none ? i : 0));
+            s = none;
+          }
+        }
+
+        if (s == close)
+        {
+          size_t m (group_.size ());
+
+          j_ = m - n;
+          if (j_ == 0)
+            throw group_separator ("{", "");
+
+          if (arg_[i_].size () != j_)
+            arg_[i_].resize (j_);
+
+          // Move from group_ to arg_. Add in reverse for ease 
+          // of iteration.
+          //
+          for (size_t j (0); j != j_; ++j)
+            arg_[i_][j] = group_[m - j - 1];
+          group_.resize (n);
+
+          pack = true;
+          break;
+        }
+        else if (s == close_plus)
+          group = true;
+        else
+          throw group_separator ((s != none ? a : ""), "}+");
+      }
+      while (scan_.more ());
+
+      // Handle the case where we have seen the leading group
+      // but there are no more arguments.
+      //
+      if (group && j_ == 0)
+        throw group_separator ("{", "");
+
+      // Handle trailing groups, if any.
+      //
+      while (scan_.more ())
+      {
+        const char* a (scan_.peek ());
+        size_t i (*a == '\\' ? 1 : 0);
+        separator s (sense (a + i));
+
+        // Next argument, argument pack, or leading group.
+        //
+        if (s == none || s == open || i != 0)
+          break;
+
+        if (s != open_plus)
+          throw group_separator (a, "");
+
+        group = true;
+
+        // Scan the group until the closing separator.
+        //
+        scan_.next ();
+        s = none;
+        while (s == none && scan_.more ())
+        {
+          a = scan_.next ();
+          i = (*a == '\\' ? 1 : 0);
+          s = sense (a + i);
+
+          if (s == none || i != 0)
+          {
+            group_.push_back (a + (s != none ? i : 0));
+            s = none;
+          }
+        }
+
+        if (s != close)
+          throw group_separator ((s != none ? a : ""), "}");
+      }
+
+      // Handle the case where we have seen the argument pack
+      // without leading or trailing group.
+      //
+      if (pack && !group)
+        throw group_separator ("{", "");
+    }
+
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // common_options
+  //
+
+  common_options::
+  common_options ()
+  : v_ (),
+    V_ (),
+    quiet_ (),
+    verbose_ (1),
+    verbose_specified_ (false),
+    stdout_format_ (bpkg::stdout_format::lines),
+    stdout_format_specified_ (false),
+    jobs_ (),
+    jobs_specified_ (false),
+    no_result_ (),
+    structured_result_ (),
+    structured_result_specified_ (false),
+    progress_ (),
+    no_progress_ (),
+    diag_color_ (),
+    no_diag_color_ (),
+    build_ (),
+    build_specified_ (false),
+    build_option_ (),
+    build_option_specified_ (false),
+    fetch_ (),
+    fetch_specified_ (false),
+    fetch_option_ (),
+    fetch_option_specified_ (false),
+    curl_ (),
+    curl_specified_ (false),
+    curl_option_ (),
+    curl_option_specified_ (false),
+    fetch_timeout_ (),
+    fetch_timeout_specified_ (false),
+    pkg_proxy_ (),
+    pkg_proxy_specified_ (false),
+    git_ ("git"),
+    git_specified_ (false),
+    git_option_ (),
+    git_option_specified_ (false),
+    sha256_ (),
+    sha256_specified_ (false),
+    sha256_option_ (),
+    sha256_option_specified_ (false),
+    tar_ (),
+    tar_specified_ (false),
+    tar_option_ (),
+    tar_option_specified_ (false),
+    openssl_ ("openssl"),
+    openssl_specified_ (false),
+    openssl_option_ (),
+    openssl_option_specified_ (false),
+    auth_ (bpkg::auth::remote),
+    auth_specified_ (false),
+    trust_ (),
+    trust_specified_ (false),
+    trust_yes_ (),
+    trust_no_ (),
+    git_capabilities_ (),
+    git_capabilities_specified_ (false),
+    pager_ (),
+    pager_specified_ (false),
+    pager_option_ (),
+    pager_option_specified_ (false),
+    options_file_ (),
+    options_file_specified_ (false),
+    default_options_ (),
+    default_options_specified_ (false),
+    no_default_options_ (),
+    keep_tmp_ ()
+  {
+  }
+
+  void common_options::
+  merge (const common_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    if (a.v_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->v_, a.v_);
+    }
+
+    if (a.V_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->V_, a.V_);
+    }
+
+    if (a.quiet_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->quiet_, a.quiet_);
+    }
+
+    if (a.verbose_specified_)
+    {
+      ::bpkg::cli::parser< uint16_t>::merge (
+        this->verbose_, a.verbose_);
+      this->verbose_specified_ = true;
+    }
+
+    if (a.stdout_format_specified_)
+    {
+      ::bpkg::cli::parser< bpkg::stdout_format>::merge (
+        this->stdout_format_, a.stdout_format_);
+      this->stdout_format_specified_ = true;
+    }
+
+    if (a.jobs_specified_)
+    {
+      ::bpkg::cli::parser< size_t>::merge (
+        this->jobs_, a.jobs_);
+      this->jobs_specified_ = true;
+    }
+
+    if (a.no_result_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_result_, a.no_result_);
+    }
+
+    if (a.structured_result_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->structured_result_, a.structured_result_);
+      this->structured_result_specified_ = true;
+    }
+
+    if (a.progress_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->progress_, a.progress_);
+    }
+
+    if (a.no_progress_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_progress_, a.no_progress_);
+    }
+
+    if (a.diag_color_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->diag_color_, a.diag_color_);
+    }
+
+    if (a.no_diag_color_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_diag_color_, a.no_diag_color_);
+    }
+
+    if (a.build_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->build_, a.build_);
+      this->build_specified_ = true;
+    }
+
+    if (a.build_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->build_option_, a.build_option_);
+      this->build_option_specified_ = true;
+    }
+
+    if (a.fetch_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->fetch_, a.fetch_);
+      this->fetch_specified_ = true;
+    }
+
+    if (a.fetch_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fetch_option_, a.fetch_option_);
+      this->fetch_option_specified_ = true;
+    }
+
+    if (a.curl_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->curl_, a.curl_);
+      this->curl_specified_ = true;
+    }
+
+    if (a.curl_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->curl_option_, a.curl_option_);
+      this->curl_option_specified_ = true;
+    }
+
+    if (a.fetch_timeout_specified_)
+    {
+      ::bpkg::cli::parser< size_t>::merge (
+        this->fetch_timeout_, a.fetch_timeout_);
+      this->fetch_timeout_specified_ = true;
+    }
+
+    if (a.pkg_proxy_specified_)
+    {
+      ::bpkg::cli::parser< butl::url>::merge (
+        this->pkg_proxy_, a.pkg_proxy_);
+      this->pkg_proxy_specified_ = true;
+    }
+
+    if (a.git_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->git_, a.git_);
+      this->git_specified_ = true;
+    }
+
+    if (a.git_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->git_option_, a.git_option_);
+      this->git_option_specified_ = true;
+    }
+
+    if (a.sha256_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->sha256_, a.sha256_);
+      this->sha256_specified_ = true;
+    }
+
+    if (a.sha256_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->sha256_option_, a.sha256_option_);
+      this->sha256_option_specified_ = true;
+    }
+
+    if (a.tar_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->tar_, a.tar_);
+      this->tar_specified_ = true;
+    }
+
+    if (a.tar_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->tar_option_, a.tar_option_);
+      this->tar_option_specified_ = true;
+    }
+
+    if (a.openssl_specified_)
+    {
+      ::bpkg::cli::parser< qualified_option<openssl_commands, path>>::merge (
+        this->openssl_, a.openssl_);
+      this->openssl_specified_ = true;
+    }
+
+    if (a.openssl_option_specified_)
+    {
+      ::bpkg::cli::parser< qualified_option<openssl_commands, strings>>::merge (
+        this->openssl_option_, a.openssl_option_);
+      this->openssl_option_specified_ = true;
+    }
+
+    if (a.auth_specified_)
+    {
+      ::bpkg::cli::parser< bpkg::auth>::merge (
+        this->auth_, a.auth_);
+      this->auth_specified_ = true;
+    }
+
+    if (a.trust_specified_)
+    {
+      ::bpkg::cli::parser< std::set<string, icase_compare_string>>::merge (
+        this->trust_, a.trust_);
+      this->trust_specified_ = true;
+    }
+
+    if (a.trust_yes_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->trust_yes_, a.trust_yes_);
+    }
+
+    if (a.trust_no_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->trust_no_, a.trust_no_);
+    }
+
+    if (a.git_capabilities_specified_)
+    {
+      ::bpkg::cli::parser< git_capabilities_map>::merge (
+        this->git_capabilities_, a.git_capabilities_);
+      this->git_capabilities_specified_ = true;
+    }
+
+    if (a.pager_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->pager_, a.pager_);
+      this->pager_specified_ = true;
+    }
+
+    if (a.pager_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->pager_option_, a.pager_option_);
+      this->pager_option_specified_ = true;
+    }
+
+    if (a.options_file_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->options_file_, a.options_file_);
+      this->options_file_specified_ = true;
+    }
+
+    if (a.default_options_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->default_options_, a.default_options_);
+      this->default_options_specified_ = true;
+    }
+
+    if (a.no_default_options_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_default_options_, a.no_default_options_);
+    }
+
+    if (a.keep_tmp_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_tmp_, a.keep_tmp_);
+    }
+  }
+
+  ::bpkg::cli::usage_para common_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mCOMMON OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "The common options are summarized below with a more detailed description" << ::std::endl
+       << "available in \033[1mbpkg-common-options(1)\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m-v\033[0m                        Print essential underlying commands being executed." << ::std::endl;
+
+    os << "\033[1m-V\033[0m                        Print all underlying commands being executed." << ::std::endl;
+
+    os << "\033[1m--quiet\033[0m|\033[1m-q\033[0m                Run quietly, only printing error messages." << ::std::endl;
+
+    os << "\033[1m--verbose\033[0m \033[4mlevel\033[0m           Set the diagnostics verbosity to \033[4mlevel\033[0m between 0 and" << ::std::endl
+       << "                          6." << ::std::endl;
+
+    os << "\033[1m--stdout-format\033[0m \033[4mformat\033[0m    Representation format to use for printing to \033[1mstdout\033[0m." << ::std::endl;
+
+    os << "\033[1m--jobs\033[0m|\033[1m-j\033[0m \033[4mnum\033[0m             Number of jobs to perform in parallel." << ::std::endl;
+
+    os << "\033[1m--no-result\033[0m               Don't print informational messages about the outcome" << ::std::endl
+       << "                          of performing a command or some of its parts." << ::std::endl;
+
+    os << "\033[1m--structured-result\033[0m \033[4mfmt\033[0m   Write the result of performing a command in a" << ::std::endl
+       << "                          structured form." << ::std::endl;
+
+    os << "\033[1m--progress\033[0m                Display progress indicators for long-lasting" << ::std::endl
+       << "                          operations, such as network transfers, building, etc." << ::std::endl;
+
+    os << "\033[1m--no-progress\033[0m             Suppress progress indicators for long-lasting" << ::std::endl
+       << "                          operations, such as network transfers, building, etc." << ::std::endl;
+
+    os << "\033[1m--diag-color\033[0m              Use color in diagnostics." << ::std::endl;
+
+    os << "\033[1m--no-diag-color\033[0m           Don't use color in diagnostics." << ::std::endl;
+
+    os << "\033[1m--build\033[0m \033[4mpath\033[0m              The build program to be used to build packages." << ::std::endl;
+
+    os << "\033[1m--build-option\033[0m \033[4mopt\033[0m        Additional option to be passed to the build program." << ::std::endl;
+
+    os << "\033[1m--fetch\033[0m \033[4mpath\033[0m              The fetch program to be used to download resources." << ::std::endl;
+
+    os << "\033[1m--fetch-option\033[0m \033[4mopt\033[0m        Additional option to be passed to the fetch program." << ::std::endl;
+
+    os << "\033[1m--fetch-timeout\033[0m \033[4msec\033[0m       The fetch and fetch-like (for example, \033[1mgit\033[0m) program" << ::std::endl
+       << "                          timeout." << ::std::endl;
+
+    os << "\033[1m--pkg-proxy\033[0m \033[4murl\033[0m           HTTP proxy server to use when fetching package" << ::std::endl
+       << "                          manifests and archives from remote \033[1mpkg\033[0m repositories." << ::std::endl;
+
+    os << "\033[1m--git\033[0m \033[4mpath\033[0m                The git program to be used to fetch git repositories." << ::std::endl;
+
+    os << "\033[1m--git-option\033[0m \033[4mopt\033[0m          Additional common option to be passed to the git" << ::std::endl
+       << "                          program." << ::std::endl;
+
+    os << "\033[1m--sha256\033[0m \033[4mpath\033[0m             The sha256 program to be used to calculate SHA256" << ::std::endl
+       << "                          sums." << ::std::endl;
+
+    os << "\033[1m--sha256-option\033[0m \033[4mopt\033[0m       Additional option to be passed to the sha256 program." << ::std::endl;
+
+    os << "\033[1m--tar\033[0m \033[4mpath\033[0m                The tar program to be used to extract package" << ::std::endl
+       << "                          archives." << ::std::endl;
+
+    os << "\033[1m--tar-option\033[0m \033[4mopt\033[0m          Additional option to be passed to the tar program." << ::std::endl;
+
+    os << "\033[1m--openssl\033[0m \033[4mpath\033[0m            The openssl program to be used for crypto operations." << ::std::endl;
+
+    os << "\033[1m--openssl-option\033[0m \033[4mopt\033[0m      Additional option to be passed to the openssl" << ::std::endl
+       << "                          program." << ::std::endl;
+
+    os << "\033[1m--auth\033[0m \033[4mtype\033[0m               Types of repositories to authenticate." << ::std::endl;
+
+    os << "\033[1m--trust\033[0m \033[4mfingerprint\033[0m       Trust repository certificate with a SHA256" << ::std::endl
+       << "                          \033[4mfingerprint\033[0m." << ::std::endl;
+
+    os << "\033[1m--trust-yes\033[0m               Assume the answer to all authentication prompts is" << ::std::endl
+       << "                          \033[1myes\033[0m." << ::std::endl;
+
+    os << "\033[1m--trust-no\033[0m                Assume the answer to all authentication prompts is" << ::std::endl
+       << "                          \033[1mno\033[0m." << ::std::endl;
+
+    os << "\033[1m--git-capabilities\033[0m \033[4mup\033[0m=\033[4mpc\033[0m  Protocol capabilities (\033[4mpc\033[0m) for a \033[1mgit\033[0m repository URL" << ::std::endl
+       << "                          prefix (\033[4mup\033[0m)." << ::std::endl;
+
+    os << "\033[1m--pager\033[0m \033[4mpath\033[0m              The pager program to be used to show long text." << ::std::endl;
+
+    os << "\033[1m--pager-option\033[0m \033[4mopt\033[0m        Additional option to be passed to the pager program." << ::std::endl;
+
+    os << "\033[1m--options-file\033[0m \033[4mfile\033[0m       Read additional options from \033[4mfile\033[0m." << ::std::endl;
+
+    os << "\033[1m--default-options\033[0m \033[4mdir\033[0m     The directory to load additional default options" << ::std::endl
+       << "                          files from." << ::std::endl;
+
+    os << "\033[1m--no-default-options\033[0m      Don't load default options files." << ::std::endl;
+
+    os << "\033[1m--keep-tmp\033[0m                Don't remove the \033[1mbpkg\033[0m's temporary directory at the" << ::std::endl
+       << "                          end of the command execution and print its path at" << ::std::endl
+       << "                          the verbosity level 2 or higher." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  ::bpkg::cli::usage_para common_options::
+  print_long_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mCOMMON OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m-v\033[0m                        Print essential underlying commands being executed." << ::std::endl
+       << "                          This is equivalent to \033[1m--verbose 2\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m-V\033[0m                        Print all underlying commands being executed. This is" << ::std::endl
+       << "                          equivalent to \033[1m--verbose 3\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--quiet\033[0m|\033[1m-q\033[0m                Run quietly, only printing error messages. This is" << ::std::endl
+       << "                          equivalent to \033[1m--verbose 0\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--verbose\033[0m \033[4mlevel\033[0m           Set the diagnostics verbosity to \033[4mlevel\033[0m between 0 and" << ::std::endl
+       << "                          6. Level 0 disables any non-error messages while" << ::std::endl
+       << "                          level 6 produces lots of information, with level 1" << ::std::endl
+       << "                          being the default. The following additional types of" << ::std::endl
+       << "                          diagnostics are produced at each level:" << ::std::endl
+       << ::std::endl
+       << "                          1. High-level information messages." << ::std::endl
+       << "                          2. Essential underlying commands being executed." << ::std::endl
+       << "                          3. All underlying commands being executed." << ::std::endl
+       << "                          4. Information that could be helpful to the user." << ::std::endl
+       << "                          5. Information that could be helpful to the" << ::std::endl
+       << "                          developer." << ::std::endl
+       << "                          6. Even more detailed information." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--stdout-format\033[0m \033[4mformat\033[0m    Representation format to use for printing to \033[1mstdout\033[0m." << ::std::endl
+       << "                          Valid values for this option are \033[1mlines\033[0m (default) and" << ::std::endl
+       << "                          \033[1mjson\033[0m. See the JSON OUTPUT section below for details" << ::std::endl
+       << "                          on the \033[1mjson\033[0m format." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--jobs\033[0m|\033[1m-j\033[0m \033[4mnum\033[0m             Number of jobs to perform in parallel. If this option" << ::std::endl
+       << "                          is not specified or specified with the 0\033[0m value, then" << ::std::endl
+       << "                          the number of available hardware threads is used." << ::std::endl
+       << "                          This option is also propagated when performing build" << ::std::endl
+       << "                          system operations such as \033[1mupdate\033[0m, \033[1mtest\033[0m, etc." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-result\033[0m               Don't print informational messages about the outcome" << ::std::endl
+       << "                          of performing a command or some of its parts. Note" << ::std::endl
+       << "                          that if this option is specified, then for certain" << ::std::endl
+       << "                          long-running command parts progress is displayed" << ::std::endl
+       << "                          instead, unless suppressed with \033[1m--no-progress\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--structured-result\033[0m \033[4mfmt\033[0m   Write the result of performing a command in a" << ::std::endl
+       << "                          structured form. In this mode, instead of printing to" << ::std::endl
+       << "                          \033[1mstderr\033[0m informational messages about the outcome of" << ::std::endl
+       << "                          performing a command or some of its parts, \033[1mbpkg\033[0m" << ::std::endl
+       << "                          writes to \033[1mstdout\033[0m a machine-readable result" << ::std::endl
+       << "                          description in the specified format. Not all commands" << ::std::endl
+       << "                          support producing structured result and valid \033[4mfmt\033[0m" << ::std::endl
+       << "                          values are command-specific. Consult the command" << ::std::endl
+       << "                          documentation for details." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--progress\033[0m                Display progress indicators for long-lasting" << ::std::endl
+       << "                          operations, such as network transfers, building, etc." << ::std::endl
+       << "                          If printing to a terminal the progress is displayed" << ::std::endl
+       << "                          by default for low verbosity levels. Use" << ::std::endl
+       << "                          \033[1m--no-progress\033[0m to suppress." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-progress\033[0m             Suppress progress indicators for long-lasting" << ::std::endl
+       << "                          operations, such as network transfers, building, etc." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--diag-color\033[0m              Use color in diagnostics. If printing to a terminal" << ::std::endl
+       << "                          the color is used by default provided the terminal is" << ::std::endl
+       << "                          not dumb. Use \033[1m--no-diag-color\033[0m to suppress." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-diag-color\033[0m           Don't use color in diagnostics." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--build\033[0m \033[4mpath\033[0m              The build program to be used to build packages. This" << ::std::endl
+       << "                          should be the path to the build2 \033[1mb\033[0m executable. You" << ::std::endl
+       << "                          can also specify additional options that should be" << ::std::endl
+       << "                          passed to the build program with \033[1m--build-option\033[0m." << ::std::endl
+       << ::std::endl
+       << "                          If the build program is not explicitly specified," << ::std::endl
+       << "                          then \033[1mbpkg\033[0m will by default use \033[1mb\033[0m plus an executable" << ::std::endl
+       << "                          suffix if one was specified when building \033[1mbpkg\033[0m. So," << ::std::endl
+       << "                          for example, if \033[1mbpkg\033[0m name was set to \033[1mbpkg-1.0\033[0m, then" << ::std::endl
+       << "                          it will look for \033[1mb-1.0\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--build-option\033[0m \033[4mopt\033[0m        Additional option to be passed to the build program." << ::std::endl
+       << "                          See \033[1m--build\033[0m for more information on the build" << ::std::endl
+       << "                          program. Repeat this option to specify multiple build" << ::std::endl
+       << "                          options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fetch\033[0m \033[4mpath\033[0m              The fetch program to be used to download resources." << ::std::endl
+       << "                          Currently, \033[1mbpkg\033[0m recognizes \033[1mcurl\033[0m, \033[1mwget\033[0m, and \033[1mfetch\033[0m." << ::std::endl
+       << "                          Note that the last component of \033[4mpath\033[0m must contain one" << ::std::endl
+       << "                          of these names as a substring in order for \033[1mbpkg\033[0m to" << ::std::endl
+       << "                          recognize which program is being used. You can also" << ::std::endl
+       << "                          specify additional options that should be passed to" << ::std::endl
+       << "                          the fetch program with \033[1m--fetch-option\033[0m." << ::std::endl
+       << ::std::endl
+       << "                          If the fetch program is not specified, then \033[1mbpkg\033[0m will" << ::std::endl
+       << "                          try to discover if one of the above programs is" << ::std::endl
+       << "                          available and use that. Currently, \033[1mbpkg\033[0m has the" << ::std::endl
+       << "                          following preference order: \033[1mcurl\033[0m, \033[1mwget\033[0m, and \033[1mfetch\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fetch-option\033[0m \033[4mopt\033[0m        Additional option to be passed to the fetch program." << ::std::endl
+       << "                          See \033[1m--fetch\033[0m for more information on the fetch" << ::std::endl
+       << "                          program. Repeat this option to specify multiple fetch" << ::std::endl
+       << "                          options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fetch-timeout\033[0m \033[4msec\033[0m       The fetch and fetch-like (for example, \033[1mgit\033[0m) program" << ::std::endl
+       << "                          timeout. While the exact semantics of the value" << ::std::endl
+       << "                          depends on the program used, at a minimum it" << ::std::endl
+       << "                          specifies in seconds the maximum time that can be" << ::std::endl
+       << "                          spent without any network activity." << ::std::endl
+       << ::std::endl
+       << "                          Specifically, it is translated to the \033[1m--max-time\033[0m" << ::std::endl
+       << "                          option for \033[1mcurl\033[0m and to the \033[1m--timeout\033[0m option for \033[1mwget\033[0m" << ::std::endl
+       << "                          and \033[1mfetch\033[0m. For \033[1mgit\033[0m over HTTP/HTTPS this semantics is" << ::std::endl
+       << "                          achieved using the \033[1mhttp.lowSpeedLimit\033[0m=\033[4m1\033[0m" << ::std::endl
+       << "                          \033[1mhttp.lowSpeedTime\033[0m=\033[4msec\033[0m configuration values (the" << ::std::endl
+       << "                          \033[1mgit://\033[0m and \033[1mssh://\033[0m protocols currently do not support" << ::std::endl
+       << "                          timeouts)." << ::std::endl
+       << ::std::endl
+       << "                          See \033[1m--fetch\033[0m and \033[1m--git\033[0m for more information on the" << ::std::endl
+       << "                          fetch programs." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--pkg-proxy\033[0m \033[4murl\033[0m           HTTP proxy server to use when fetching package" << ::std::endl
+       << "                          manifests and archives from remote \033[1mpkg\033[0m repositories." << ::std::endl
+       << "                          If specified, the proxy \033[4murl\033[0m must be in the" << ::std::endl
+       << "                          \033[1mhttp://\033[0m\033[4mhost\033[0m[\033[1m:\033[0m\033[4mport\033[0m]\033[0m form. If \033[4mport\033[0m is omitted, 80 is" << ::std::endl
+       << "                          used by default." << ::std::endl
+       << ::std::endl
+       << "                          Note that to allow caching, the proxied \033[1mhttps://\033[0m URLs" << ::std::endl
+       << "                          are converted to \033[1mhttp://\033[0m in order to prevent the" << ::std::endl
+       << "                          fetch program from tunneling (which is the standard" << ::std::endl
+       << "                          approach for proxying HTTPS). If both HTTP and HTTPS" << ::std::endl
+       << "                          repositories are used, it is assumed that the proxy" << ::std::endl
+       << "                          server can figure out which URLs need to be converted" << ::std::endl
+       << "                          back to \033[1mhttps://\033[0m based on the request information" << ::std::endl
+       << "                          (for example, host name). For security, this" << ::std::endl
+       << "                          mechanism should only be used with signed" << ::std::endl
+       << "                          repositories or when the proxy is located inside a" << ::std::endl
+       << "                          trusted network." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--git\033[0m \033[4mpath\033[0m                The git program to be used to fetch git repositories." << ::std::endl
+       << "                          You can also specify additional options that should" << ::std::endl
+       << "                          be passed to the git program with \033[1m--git-option\033[0m." << ::std::endl
+       << ::std::endl
+       << "                          If the git program is not explicitly specified, then" << ::std::endl
+       << "                          \033[1mbpkg\033[0m will use \033[1mgit\033[0m by default." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--git-option\033[0m \033[4mopt\033[0m          Additional common option to be passed to the git" << ::std::endl
+       << "                          program. Note that the common options are the ones" << ::std::endl
+       << "                          that precede the \033[1mgit\033[0m command. See \033[1m--git\033[0m for more" << ::std::endl
+       << "                          information on the git program. Repeat this option to" << ::std::endl
+       << "                          specify multiple git options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sha256\033[0m \033[4mpath\033[0m             The sha256 program to be used to calculate SHA256" << ::std::endl
+       << "                          sums. Currently, \033[1mbpkg\033[0m recognizes \033[1msha256\033[0m, \033[1msha256sum\033[0m," << ::std::endl
+       << "                          and \033[1mshasum\033[0m. Note that the last component of \033[4mpath\033[0m must" << ::std::endl
+       << "                          contain one of these names as a substring in order" << ::std::endl
+       << "                          for \033[1mbpkg\033[0m to recognize which program is being used." << ::std::endl
+       << "                          You can also specify additional options that should" << ::std::endl
+       << "                          be passed to the sha256 program with \033[1m--sha256-option\033[0m." << ::std::endl
+       << ::std::endl
+       << "                          If the sha256 program is not specified, then \033[1mbpkg\033[0m" << ::std::endl
+       << "                          will try to discover if one of the above programs is" << ::std::endl
+       << "                          available and use that. Currently, \033[1mbpkg\033[0m has the" << ::std::endl
+       << "                          following preference order: \033[1msha256\033[0m, \033[1msha256sum\033[0m, and" << ::std::endl
+       << "                          \033[1mshasum\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sha256-option\033[0m \033[4mopt\033[0m       Additional option to be passed to the sha256 program." << ::std::endl
+       << "                          See \033[1m--sha256\033[0m for more information on the sha256" << ::std::endl
+       << "                          program. Repeat this option to specify multiple" << ::std::endl
+       << "                          sha256 options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--tar\033[0m \033[4mpath\033[0m                The tar program to be used to extract package" << ::std::endl
+       << "                          archives. For example, \033[1mgtar\033[0m or \033[1mbsdtar\033[0m. You can also" << ::std::endl
+       << "                          specify additional options that should be passed to" << ::std::endl
+       << "                          the tar program with \033[1m--tar-option\033[0m. If the tar program" << ::std::endl
+       << "                          is not explicitly specified, then \033[1mbpkg\033[0m will use \033[1mtar\033[0m" << ::std::endl
+       << "                          by default." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--tar-option\033[0m \033[4mopt\033[0m          Additional option to be passed to the tar program." << ::std::endl
+       << "                          See \033[1m--tar\033[0m for more information on the tar program." << ::std::endl
+       << "                          Repeat this option to specify multiple tar options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--openssl\033[0m \033[4mpath\033[0m            The openssl program to be used for crypto operations." << ::std::endl
+       << "                          You can also specify additional options that should" << ::std::endl
+       << "                          be passed to the openssl program with" << ::std::endl
+       << "                          \033[1m--openssl-option\033[0m. If the openssl program is not" << ::std::endl
+       << "                          explicitly specified, then \033[1mbpkg\033[0m will use \033[1mopenssl\033[0m by" << ::std::endl
+       << "                          default." << ::std::endl
+       << ::std::endl
+       << "                          The \033[1m--openssl*\033[0m values can be optionally qualified" << ::std::endl
+       << "                          with the openssl command in the \033[4mcommand\033[0m\033[1m:\033[0m\033[4mvalue\033[0m\033[0m form." << ::std::endl
+       << "                          This makes the value only applicable to the specific" << ::std::endl
+       << "                          command, for example:" << ::std::endl
+       << ::std::endl
+       << "                          bpkg rep-create                      \\" << ::std::endl
+       << "                            --openssl pkeyutl:/path/to/openssl \\" << ::std::endl
+       << "                            --openssl-option pkeyutl:-engine   \\" << ::std::endl
+       << "                            --openssl-option pkeyutl:pkcs11    \\" << ::std::endl
+       << "                            ..." << ::std::endl
+       << ::std::endl
+       << "                          Note that for \033[1mopenssl\033[0m versions prior to \033[1m3.0.0\033[0m \033[1mbpkg\033[0m" << ::std::endl
+       << "                          uses the \033[1mrsautl\033[0m command instead of \033[1mpkeyutl\033[0m for the" << ::std::endl
+       << "                          data signing and recovery operations." << ::std::endl
+       << ::std::endl
+       << "                          An unqualified value that contains a colon can be" << ::std::endl
+       << "                          specified as qualified with an empty command, for" << ::std::endl
+       << "                          example, \033[1m--openssl :C:\\bin\\openssl\033[0m. To see openssl" << ::std::endl
+       << "                          commands executed by \033[1mbpkg\033[0m, use the verbose mode (\033[1m-v\033[0m" << ::std::endl
+       << "                          option)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--openssl-option\033[0m \033[4mopt\033[0m      Additional option to be passed to the openssl" << ::std::endl
+       << "                          program. See \033[1m--openssl\033[0m for more information on the" << ::std::endl
+       << "                          openssl program. The values can be optionally" << ::std::endl
+       << "                          qualified with the openssl command, as discussed in" << ::std::endl
+       << "                          \033[1m--openssl\033[0m. Repeat this option to specify multiple" << ::std::endl
+       << "                          openssl options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--auth\033[0m \033[4mtype\033[0m               Types of repositories to authenticate. Valid values" << ::std::endl
+       << "                          for this option are \033[1mnone\033[0m, \033[1mremote\033[0m, \033[1mall\033[0m. By default" << ::std::endl
+       << "                          only remote repositories are authenticated. You can" << ::std::endl
+       << "                          request authentication of local repositories by" << ::std::endl
+       << "                          passing \033[1mall\033[0m or disable authentication completely by" << ::std::endl
+       << "                          passing \033[1mnone\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--trust\033[0m \033[4mfingerprint\033[0m       Trust repository certificate with a SHA256" << ::std::endl
+       << "                          \033[4mfingerprint\033[0m. Such a certificate is trusted" << ::std::endl
+       << "                          automatically, without prompting the user for a" << ::std::endl
+       << "                          confirmation. Repeat this option to trust multiple" << ::std::endl
+       << "                          certificates." << ::std::endl
+       << ::std::endl
+       << "                          Note that by default \033[1mopenssl\033[0m prints a SHA1" << ::std::endl
+       << "                          fingerprint and to obtain a SHA256 one you will need" << ::std::endl
+       << "                          to pass the \033[1m-sha256\033[0m option, for example:" << ::std::endl
+       << ::std::endl
+       << "                          openssl x509 -sha256 -fingerprint -noout -in cert.pem" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--trust-yes\033[0m               Assume the answer to all authentication prompts is" << ::std::endl
+       << "                          \033[1myes\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--trust-no\033[0m                Assume the answer to all authentication prompts is" << ::std::endl
+       << "                          \033[1mno\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--git-capabilities\033[0m \033[4mup\033[0m=\033[4mpc\033[0m  Protocol capabilities (\033[4mpc\033[0m) for a \033[1mgit\033[0m repository URL" << ::std::endl
+       << "                          prefix (\033[4mup\033[0m). Valid values for the capabilities are" << ::std::endl
+       << "                          \033[1mdumb\033[0m (no shallow clone support), \033[1msmart\033[0m (support for" << ::std::endl
+       << "                          shallow clone, but not for fetching unadvertised" << ::std::endl
+       << "                          commits), \033[1munadv\033[0m (support for shallow clone and for" << ::std::endl
+       << "                          fetching unadvertised commits). For example:" << ::std::endl
+       << ::std::endl
+       << "                          bpkg build https://example.org/foo.git#master \\" << ::std::endl
+       << "                            --git-capabilities https://example.org=smart" << ::std::endl
+       << ::std::endl
+       << "                          See \033[1mbpkg-repository-types(1)\033[0m for details on the \033[1mgit\033[0m" << ::std::endl
+       << "                          protocol capabilities." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--pager\033[0m \033[4mpath\033[0m              The pager program to be used to show long text." << ::std::endl
+       << "                          Commonly used pager programs are \033[1mless\033[0m and \033[1mmore\033[0m. You" << ::std::endl
+       << "                          can also specify additional options that should be" << ::std::endl
+       << "                          passed to the pager program with \033[1m--pager-option\033[0m. If" << ::std::endl
+       << "                          an empty string is specified as the pager program," << ::std::endl
+       << "                          then no pager will be used. If the pager program is" << ::std::endl
+       << "                          not explicitly specified, then \033[1mbpkg\033[0m will try to use" << ::std::endl
+       << "                          \033[1mless\033[0m. If it is not available, then no pager will be" << ::std::endl
+       << "                          used." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--pager-option\033[0m \033[4mopt\033[0m        Additional option to be passed to the pager program." << ::std::endl
+       << "                          See \033[1m--pager\033[0m for more information on the pager" << ::std::endl
+       << "                          program. Repeat this option to specify multiple pager" << ::std::endl
+       << "                          options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--options-file\033[0m \033[4mfile\033[0m       Read additional options from \033[4mfile\033[0m. Each option should" << ::std::endl
+       << "                          appear on a separate line optionally followed by" << ::std::endl
+       << "                          space or equal sign (\033[1m=\033[0m) and an option value. Empty" << ::std::endl
+       << "                          lines and lines starting with \033[1m#\033[0m are ignored. Option" << ::std::endl
+       << "                          values can be enclosed in double (\033[1m\"\033[0m) or single (\033[1m'\033[0m)" << ::std::endl
+       << "                          quotes to preserve leading and trailing whitespaces" << ::std::endl
+       << "                          as well as to specify empty values. If the value" << ::std::endl
+       << "                          itself contains trailing or leading quotes, enclose" << ::std::endl
+       << "                          it with an extra pair of quotes, for example \033[1m'\"x\"'\033[0m." << ::std::endl
+       << "                          Non-leading and non-trailing quotes are interpreted" << ::std::endl
+       << "                          as being part of the option value." << ::std::endl
+       << ::std::endl
+       << "                          The semantics of providing options in a file is" << ::std::endl
+       << "                          equivalent to providing the same set of options in" << ::std::endl
+       << "                          the same order on the command line at the point where" << ::std::endl
+       << "                          the \033[1m--options-file\033[0m option is specified except that" << ::std::endl
+       << "                          the shell escaping and quoting is not required." << ::std::endl
+       << "                          Repeat this option to specify more than one options" << ::std::endl
+       << "                          file." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--default-options\033[0m \033[4mdir\033[0m     The directory to load additional default options" << ::std::endl
+       << "                          files from." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-default-options\033[0m      Don't load default options files." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-tmp\033[0m                Don't remove the \033[1mbpkg\033[0m's temporary directory at the" << ::std::endl
+       << "                          end of the command execution and print its path at" << ::std::endl
+       << "                          the verbosity level 2 or higher. This option is" << ::std::endl
+       << "                          primarily useful for troubleshooting." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (common_options&, ::bpkg::cli::scanner&)>
+  _cli_common_options_map;
+
+  static _cli_common_options_map _cli_common_options_map_;
+
+  struct _cli_common_options_map_init
+  {
+    _cli_common_options_map_init ()
+    {
+      _cli_common_options_map_["-v"] =
+      &::bpkg::cli::thunk< common_options, &common_options::v_ >;
+      _cli_common_options_map_["-V"] =
+      &::bpkg::cli::thunk< common_options, &common_options::V_ >;
+      _cli_common_options_map_["--quiet"] =
+      &::bpkg::cli::thunk< common_options, &common_options::quiet_ >;
+      _cli_common_options_map_["-q"] =
+      &::bpkg::cli::thunk< common_options, &common_options::quiet_ >;
+      _cli_common_options_map_["--verbose"] =
+      &::bpkg::cli::thunk< common_options, uint16_t, &common_options::verbose_,
+        &common_options::verbose_specified_ >;
+      _cli_common_options_map_["--stdout-format"] =
+      &::bpkg::cli::thunk< common_options, bpkg::stdout_format, &common_options::stdout_format_,
+        &common_options::stdout_format_specified_ >;
+      _cli_common_options_map_["--jobs"] =
+      &::bpkg::cli::thunk< common_options, size_t, &common_options::jobs_,
+        &common_options::jobs_specified_ >;
+      _cli_common_options_map_["-j"] =
+      &::bpkg::cli::thunk< common_options, size_t, &common_options::jobs_,
+        &common_options::jobs_specified_ >;
+      _cli_common_options_map_["--no-result"] =
+      &::bpkg::cli::thunk< common_options, &common_options::no_result_ >;
+      _cli_common_options_map_["--structured-result"] =
+      &::bpkg::cli::thunk< common_options, string, &common_options::structured_result_,
+        &common_options::structured_result_specified_ >;
+      _cli_common_options_map_["--progress"] =
+      &::bpkg::cli::thunk< common_options, &common_options::progress_ >;
+      _cli_common_options_map_["--no-progress"] =
+      &::bpkg::cli::thunk< common_options, &common_options::no_progress_ >;
+      _cli_common_options_map_["--diag-color"] =
+      &::bpkg::cli::thunk< common_options, &common_options::diag_color_ >;
+      _cli_common_options_map_["--no-diag-color"] =
+      &::bpkg::cli::thunk< common_options, &common_options::no_diag_color_ >;
+      _cli_common_options_map_["--build"] =
+      &::bpkg::cli::thunk< common_options, path, &common_options::build_,
+        &common_options::build_specified_ >;
+      _cli_common_options_map_["--build-option"] =
+      &::bpkg::cli::thunk< common_options, strings, &common_options::build_option_,
+        &common_options::build_option_specified_ >;
+      _cli_common_options_map_["--fetch"] =
+      &::bpkg::cli::thunk< common_options, path, &common_options::fetch_,
+        &common_options::fetch_specified_ >;
+      _cli_common_options_map_["--fetch-option"] =
+      &::bpkg::cli::thunk< common_options, strings, &common_options::fetch_option_,
+        &common_options::fetch_option_specified_ >;
+      _cli_common_options_map_["--curl"] =
+      &::bpkg::cli::thunk< common_options, path, &common_options::curl_,
+        &common_options::curl_specified_ >;
+      _cli_common_options_map_["--curl-option"] =
+      &::bpkg::cli::thunk< common_options, strings, &common_options::curl_option_,
+        &common_options::curl_option_specified_ >;
+      _cli_common_options_map_["--fetch-timeout"] =
+      &::bpkg::cli::thunk< common_options, size_t, &common_options::fetch_timeout_,
+        &common_options::fetch_timeout_specified_ >;
+      _cli_common_options_map_["--pkg-proxy"] =
+      &::bpkg::cli::thunk< common_options, butl::url, &common_options::pkg_proxy_,
+        &common_options::pkg_proxy_specified_ >;
+      _cli_common_options_map_["--git"] =
+      &::bpkg::cli::thunk< common_options, path, &common_options::git_,
+        &common_options::git_specified_ >;
+      _cli_common_options_map_["--git-option"] =
+      &::bpkg::cli::thunk< common_options, strings, &common_options::git_option_,
+        &common_options::git_option_specified_ >;
+      _cli_common_options_map_["--sha256"] =
+      &::bpkg::cli::thunk< common_options, path, &common_options::sha256_,
+        &common_options::sha256_specified_ >;
+      _cli_common_options_map_["--sha256-option"] =
+      &::bpkg::cli::thunk< common_options, strings, &common_options::sha256_option_,
+        &common_options::sha256_option_specified_ >;
+      _cli_common_options_map_["--tar"] =
+      &::bpkg::cli::thunk< common_options, path, &common_options::tar_,
+        &common_options::tar_specified_ >;
+      _cli_common_options_map_["--tar-option"] =
+      &::bpkg::cli::thunk< common_options, strings, &common_options::tar_option_,
+        &common_options::tar_option_specified_ >;
+      _cli_common_options_map_["--openssl"] =
+      &::bpkg::cli::thunk< common_options, qualified_option<openssl_commands, path>, &common_options::openssl_,
+        &common_options::openssl_specified_ >;
+      _cli_common_options_map_["--openssl-option"] =
+      &::bpkg::cli::thunk< common_options, qualified_option<openssl_commands, strings>, &common_options::openssl_option_,
+        &common_options::openssl_option_specified_ >;
+      _cli_common_options_map_["--auth"] =
+      &::bpkg::cli::thunk< common_options, bpkg::auth, &common_options::auth_,
+        &common_options::auth_specified_ >;
+      _cli_common_options_map_["--trust"] =
+      &::bpkg::cli::thunk< common_options, std::set<string, icase_compare_string>, &common_options::trust_,
+        &common_options::trust_specified_ >;
+      _cli_common_options_map_["--trust-yes"] =
+      &::bpkg::cli::thunk< common_options, &common_options::trust_yes_ >;
+      _cli_common_options_map_["--trust-no"] =
+      &::bpkg::cli::thunk< common_options, &common_options::trust_no_ >;
+      _cli_common_options_map_["--git-capabilities"] =
+      &::bpkg::cli::thunk< common_options, git_capabilities_map, &common_options::git_capabilities_,
+        &common_options::git_capabilities_specified_ >;
+      _cli_common_options_map_["--pager"] =
+      &::bpkg::cli::thunk< common_options, string, &common_options::pager_,
+        &common_options::pager_specified_ >;
+      _cli_common_options_map_["--pager-option"] =
+      &::bpkg::cli::thunk< common_options, strings, &common_options::pager_option_,
+        &common_options::pager_option_specified_ >;
+      _cli_common_options_map_["--options-file"] =
+      &::bpkg::cli::thunk< common_options, string, &common_options::options_file_,
+        &common_options::options_file_specified_ >;
+      _cli_common_options_map_["--default-options"] =
+      &::bpkg::cli::thunk< common_options, dir_path, &common_options::default_options_,
+        &common_options::default_options_specified_ >;
+      _cli_common_options_map_["--no-default-options"] =
+      &::bpkg::cli::thunk< common_options, &common_options::no_default_options_ >;
+      _cli_common_options_map_["--keep-tmp"] =
+      &::bpkg::cli::thunk< common_options, &common_options::keep_tmp_ >;
+    }
+  };
+
+  static _cli_common_options_map_init _cli_common_options_map_init_;
+
+  bool common_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_common_options_map::const_iterator i (_cli_common_options_map_.find (o));
+
+    if (i != _cli_common_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_common_options_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg\033[0m [\033[4mcommon-options\033[0m] ...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The common options control behavior that is common to all or most of the \033[1mbpkg\033[0m" << ::std::endl
+       << "commands. They can be specified either before the command or after, together" << ::std::endl
+       << "with the command-specific options." << ::std::endl;
+
+    p = ::bpkg::common_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mJSON OUTPUT\033[0m" << ::std::endl
+       << ::std::endl
+       << "Commands that support the JSON output specify their formats as a serialized" << ::std::endl
+       << "representation of a C++ \033[1mstruct\033[0m or an array thereof. For example:" << ::std::endl
+       << ::std::endl
+       << "struct package" << ::std::endl
+       << "{" << ::std::endl
+       << "  string name;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "struct configuration" << ::std::endl
+       << "{" << ::std::endl
+       << "  uint64_t         id;" << ::std::endl
+       << "  string           path;" << ::std::endl
+       << "  optional<string> name;" << ::std::endl
+       << "  bool             default;" << ::std::endl
+       << "  vector<package>  packages;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "An example of the serialized JSON representation of \033[1mstruct\033[0m \033[1mconfiguration\033[0m:" << ::std::endl
+       << ::std::endl
+       << "{" << ::std::endl
+       << "  \"id\": 1," << ::std::endl
+       << "  \"path\": \"/tmp/hello-gcc\"," << ::std::endl
+       << "  \"name\": \"gcc\"," << ::std::endl
+       << "  \"default\": true," << ::std::endl
+       << "  \"packages\": [" << ::std::endl
+       << "    {" << ::std::endl
+       << "      \"name\": \"hello\"" << ::std::endl
+       << "    }" << ::std::endl
+       << "  ]" << ::std::endl
+       << "}" << ::std::endl
+       << ::std::endl
+       << "This sections provides details on the overall properties of such formats and" << ::std::endl
+       << "the semantics of the \033[1mstruct\033[0m serialization." << ::std::endl
+       << ::std::endl
+       << "The order of members in a JSON object is fixed as specified in the" << ::std::endl
+       << "corresponding \033[1mstruct\033[0m. While new members may be added in the future (and should" << ::std::endl
+       << "be ignored by older consumers), the semantics of the existing members" << ::std::endl
+       << "(including whether the top-level entry is an object or array) may not change." << ::std::endl
+       << ::std::endl
+       << "An object member is required unless its type is \033[1moptional<>\033[0m, \033[1mbool\033[0m, or \033[1mvector<>\033[0m" << ::std::endl
+       << "(array). For \033[1mbool\033[0m members absent means \033[1mfalse\033[0m. For \033[1mvector<>\033[0m members absent means" << ::std::endl
+       << "empty. An empty top-level array is always present." << ::std::endl
+       << ::std::endl
+       << "For example, the following JSON text is a possible serialization of the above" << ::std::endl
+       << "\033[1mstruct\033[0m \033[1mconfiguration\033[0m:" << ::std::endl
+       << ::std::endl
+       << "{" << ::std::endl
+       << "  \"id\": 1," << ::std::endl
+       << "  \"path\": \"/tmp/hello-gcc\"" << ::std::endl
+       << "}" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+
+  ::bpkg::cli::usage_para
+  print_bpkg_common_options_long_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg\033[0m [\033[4mcommon-options\033[0m] ...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The common options control behavior that is common to all or most of the \033[1mbpkg\033[0m" << ::std::endl
+       << "commands. They can be specified either before the command or after, together" << ::std::endl
+       << "with the command-specific options." << ::std::endl;
+
+    p = ::bpkg::common_options::print_long_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mJSON OUTPUT\033[0m" << ::std::endl
+       << ::std::endl
+       << "Commands that support the JSON output specify their formats as a serialized" << ::std::endl
+       << "representation of a C++ \033[1mstruct\033[0m or an array thereof. For example:" << ::std::endl
+       << ::std::endl
+       << "struct package" << ::std::endl
+       << "{" << ::std::endl
+       << "  string name;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "struct configuration" << ::std::endl
+       << "{" << ::std::endl
+       << "  uint64_t         id;" << ::std::endl
+       << "  string           path;" << ::std::endl
+       << "  optional<string> name;" << ::std::endl
+       << "  bool             default;" << ::std::endl
+       << "  vector<package>  packages;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "An example of the serialized JSON representation of \033[1mstruct\033[0m \033[1mconfiguration\033[0m:" << ::std::endl
+       << ::std::endl
+       << "{" << ::std::endl
+       << "  \"id\": 1," << ::std::endl
+       << "  \"path\": \"/tmp/hello-gcc\"," << ::std::endl
+       << "  \"name\": \"gcc\"," << ::std::endl
+       << "  \"default\": true," << ::std::endl
+       << "  \"packages\": [" << ::std::endl
+       << "    {" << ::std::endl
+       << "      \"name\": \"hello\"" << ::std::endl
+       << "    }" << ::std::endl
+       << "  ]" << ::std::endl
+       << "}" << ::std::endl
+       << ::std::endl
+       << "This sections provides details on the overall properties of such formats and" << ::std::endl
+       << "the semantics of the \033[1mstruct\033[0m serialization." << ::std::endl
+       << ::std::endl
+       << "The order of members in a JSON object is fixed as specified in the" << ::std::endl
+       << "corresponding \033[1mstruct\033[0m. While new members may be added in the future (and should" << ::std::endl
+       << "be ignored by older consumers), the semantics of the existing members" << ::std::endl
+       << "(including whether the top-level entry is an object or array) may not change." << ::std::endl
+       << ::std::endl
+       << "An object member is required unless its type is \033[1moptional<>\033[0m, \033[1mbool\033[0m, or \033[1mvector<>\033[0m" << ::std::endl
+       << "(array). For \033[1mbool\033[0m members absent means \033[1mfalse\033[0m. For \033[1mvector<>\033[0m members absent means" << ::std::endl
+       << "empty. An empty top-level array is always present." << ::std::endl
+       << ::std::endl
+       << "For example, the following JSON text is a possible serialization of the above" << ::std::endl
+       << "\033[1mstruct\033[0m \033[1mconfiguration\033[0m:" << ::std::endl
+       << ::std::endl
+       << "{" << ::std::endl
+       << "  \"id\": 1," << ::std::endl
+       << "  \"path\": \"/tmp/hello-gcc\"" << ::std::endl
+       << "}" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/common-options.hxx b/bpkg/common-options.hxx
new file mode 100644
index 0000000..0df9871
--- /dev/null
+++ b/bpkg/common-options.hxx
@@ -0,0 +1,1235 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_COMMON_OPTIONS_HXX
+#define BPKG_COMMON_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <list>
+#include <deque>
+#include <vector>
+#include <iosfwd>
+#include <string>
+#include <cstddef>
+#include <exception>
+
+#ifndef CLI_POTENTIALLY_UNUSED
+#  if defined(_MSC_VER) || defined(__xlC__)
+#    define CLI_POTENTIALLY_UNUSED(x) (void*)&x
+#  else
+#    define CLI_POTENTIALLY_UNUSED(x) (void)x
+#  endif
+#endif
+
+namespace bpkg
+{
+  namespace cli
+  {
+    class usage_para
+    {
+      public:
+      enum value
+      {
+        none,
+        text,
+        option
+      };
+
+      usage_para (value);
+
+      operator value () const 
+      {
+        return v_;
+      }
+
+      private:
+      value v_;
+    };
+
+    class unknown_mode
+    {
+      public:
+      enum value
+      {
+        skip,
+        stop,
+        fail
+      };
+
+      unknown_mode (value);
+
+      operator value () const 
+      {
+        return v_;
+      }
+
+      private:
+      value v_;
+    };
+
+    // Exceptions.
+    //
+
+    class exception: public std::exception
+    {
+      public:
+      virtual void
+      print (::std::ostream&) const = 0;
+    };
+
+    ::std::ostream&
+    operator<< (::std::ostream&, const exception&);
+
+    class unknown_option: public exception
+    {
+      public:
+      virtual
+      ~unknown_option () noexcept;
+
+      unknown_option (const std::string& option);
+
+      const std::string&
+      option () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string option_;
+    };
+
+    class unknown_argument: public exception
+    {
+      public:
+      virtual
+      ~unknown_argument () noexcept;
+
+      unknown_argument (const std::string& argument);
+
+      const std::string&
+      argument () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string argument_;
+    };
+
+    class missing_value: public exception
+    {
+      public:
+      virtual
+      ~missing_value () noexcept;
+
+      missing_value (const std::string& option);
+
+      const std::string&
+      option () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string option_;
+    };
+
+    class invalid_value: public exception
+    {
+      public:
+      virtual
+      ~invalid_value () noexcept;
+
+      invalid_value (const std::string& option,
+                     const std::string& value,
+                     const std::string& message = std::string ());
+
+      const std::string&
+      option () const;
+
+      const std::string&
+      value () const;
+
+      const std::string&
+      message () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string option_;
+      std::string value_;
+      std::string message_;
+    };
+
+    class eos_reached: public exception
+    {
+      public:
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+    };
+
+    class file_io_failure: public exception
+    {
+      public:
+      virtual
+      ~file_io_failure () noexcept;
+
+      file_io_failure (const std::string& file);
+
+      const std::string&
+      file () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string file_;
+    };
+
+    class unmatched_quote: public exception
+    {
+      public:
+      virtual
+      ~unmatched_quote () noexcept;
+
+      unmatched_quote (const std::string& argument);
+
+      const std::string&
+      argument () const;
+
+      virtual void
+      print (::std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string argument_;
+    };
+
+    class unexpected_group: public exception
+    {
+      public:
+      virtual
+      ~unexpected_group () noexcept;
+
+      unexpected_group (const std::string& argument,
+                        const std::string& group);
+
+      const std::string&
+      argument () const;
+
+      const std::string&
+      group () const;
+
+      virtual void
+      print (std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string argument_;
+      std::string group_;
+    };
+
+    class group_separator: public exception
+    {
+      public:
+      virtual
+      ~group_separator () noexcept;
+
+      // Note: either (but not both) can be empty.
+      //
+      group_separator (const std::string& encountered,
+                       const std::string& expected);
+
+      const std::string&
+      encountered () const;
+
+      const std::string&
+      expected () const;
+
+      virtual void
+      print (std::ostream&) const;
+
+      virtual const char*
+      what () const noexcept;
+
+      private:
+      std::string encountered_;
+      std::string expected_;
+    };
+
+    // Command line argument scanner interface.
+    //
+    // The values returned by next() are guaranteed to be valid
+    // for the two previous arguments up until a call to a third
+    // peek() or next().
+    //
+    // The position() function returns a monotonically-increasing
+    // number which, if stored, can later be used to determine the
+    // relative position of the argument returned by the following
+    // call to next(). Note that if multiple scanners are used to
+    // extract arguments from multiple sources, then the end
+    // position of the previous scanner should be used as the
+    // start position of the next.
+    //
+    class scanner
+    {
+      public:
+      virtual
+      ~scanner ();
+
+      virtual bool
+      more () = 0;
+
+      virtual const char*
+      peek () = 0;
+
+      virtual const char*
+      next () = 0;
+
+      virtual void
+      skip () = 0;
+
+      virtual std::size_t
+      position () = 0;
+    };
+
+    class argv_scanner: public scanner
+    {
+      public:
+      argv_scanner (int& argc,
+                    char** argv,
+                    bool erase = false,
+                    std::size_t start_position = 0);
+
+      argv_scanner (int start,
+                    int& argc,
+                    char** argv,
+                    bool erase = false,
+                    std::size_t start_position = 0);
+
+      int
+      end () const;
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      protected:
+      std::size_t start_position_;
+      int i_;
+      int& argc_;
+      char** argv_;
+      bool erase_;
+    };
+
+    class vector_scanner: public scanner
+    {
+      public:
+      vector_scanner (const std::vector<std::string>&,
+                      std::size_t start = 0,
+                      std::size_t start_position = 0);
+
+      std::size_t
+      end () const;
+
+      void
+      reset (std::size_t start = 0, std::size_t start_position = 0);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      private:
+      std::size_t start_position_;
+      const std::vector<std::string>& v_;
+      std::size_t i_;
+    };
+
+    class argv_file_scanner: public argv_scanner
+    {
+      public:
+      argv_file_scanner (int& argc,
+                         char** argv,
+                         const std::string& option,
+                         bool erase = false,
+                         std::size_t start_position = 0);
+
+      argv_file_scanner (int start,
+                         int& argc,
+                         char** argv,
+                         const std::string& option,
+                         bool erase = false,
+                         std::size_t start_position = 0);
+
+      argv_file_scanner (const std::string& file,
+                         const std::string& option,
+                         std::size_t start_position = 0);
+
+      struct option_info
+      {
+        // If search_func is not NULL, it is called, with the arg
+        // value as the second argument, to locate the options file.
+        // If it returns an empty string, then the file is ignored.
+        //
+        const char* option;
+        std::string (*search_func) (const char*, void* arg);
+        void* arg;
+      };
+
+      argv_file_scanner (int& argc,
+                          char** argv,
+                          const option_info* options,
+                          std::size_t options_count,
+                          bool erase = false,
+                          std::size_t start_position = 0);
+
+      argv_file_scanner (int start,
+                         int& argc,
+                         char** argv,
+                         const option_info* options,
+                         std::size_t options_count,
+                         bool erase = false,
+                         std::size_t start_position = 0);
+
+      argv_file_scanner (const std::string& file,
+                         const option_info* options = 0,
+                         std::size_t options_count = 0,
+                         std::size_t start_position = 0);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      // Return the file path if the peeked at argument came from a file and
+      // the empty string otherwise. The reference is guaranteed to be valid
+      // till the end of the scanner lifetime.
+      //
+      const std::string&
+      peek_file ();
+
+      // Return the 1-based line number if the peeked at argument came from
+      // a file and zero otherwise.
+      //
+      std::size_t
+      peek_line ();
+
+      private:
+      const option_info*
+      find (const char*) const;
+
+      void
+      load (const std::string& file);
+
+      typedef argv_scanner base;
+
+      const std::string option_;
+      option_info option_info_;
+      const option_info* options_;
+      std::size_t options_count_;
+
+      struct arg
+      {
+        std::string value;
+        const std::string* file;
+        std::size_t line;
+      };
+
+      std::deque<arg> args_;
+      std::list<std::string> files_;
+
+      // Circular buffer of two arguments.
+      //
+      std::string hold_[2];
+      std::size_t i_;
+
+      bool skip_;
+
+      static int zero_argc_;
+      static std::string empty_string_;
+    };
+
+    class group_scanner: public scanner
+    {
+      public:
+      group_scanner (scanner&);
+
+      virtual bool
+      more ();
+
+      virtual const char*
+      peek ();
+
+      virtual const char*
+      next ();
+
+      virtual void
+      skip ();
+
+      virtual std::size_t
+      position ();
+
+      // The group is only available after the call to next()
+      // (and skip() -- in case one needs to make sure the group
+      // was empty, or some such) and is only valid (and must be
+      // handled) until the next call to any of the scanner
+      // functions (including more()).
+      //
+      // Note also that argument positions within each group start
+      // from 0.
+      //
+      scanner&
+      group ();
+
+      // Escape an argument that is a group separator. Return the
+      // passed string if no escaping is required.
+      //
+      static const char*
+      escape (const char*);
+
+      private:
+      enum state
+      {
+        peeked,  // Argument peeked at with peek().
+        scanned, // Argument scanned with next().
+        skipped, // Argument skipped with skip()/initial.
+      };
+
+      enum separator
+      {
+        none,
+        open,      // {
+        close,     // }
+        open_plus, // +{
+        close_plus // }+
+      };
+
+      static separator
+      sense (const char*);
+
+      // Scan the leading groups, the next argument/argument pack,
+      // and the trailing groups.
+      //
+      void
+      scan_group ();
+
+      scanner& scan_;
+      state state_;
+
+      // Circular buffer of two arguments.
+      //
+      std::vector<std::string> arg_[2];
+      std::size_t i_, j_, pos_;
+
+      std::vector<std::string> group_;
+      vector_scanner group_scan_;
+    };
+
+    template <typename X>
+    struct parser;
+  }
+}
+
+#include <set>
+
+#include <bpkg/types.hxx>
+
+#include <bpkg/options-types.hxx>
+
+namespace bpkg
+{
+  class common_options
+  {
+    public:
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const common_options&);
+
+    // Option accessors and modifiers.
+    //
+    const bool&
+    v () const;
+
+    bool&
+    v ();
+
+    void
+    v (const bool&);
+
+    const bool&
+    V () const;
+
+    bool&
+    V ();
+
+    void
+    V (const bool&);
+
+    const bool&
+    quiet () const;
+
+    bool&
+    quiet ();
+
+    void
+    quiet (const bool&);
+
+    const uint16_t&
+    verbose () const;
+
+    uint16_t&
+    verbose ();
+
+    void
+    verbose (const uint16_t&);
+
+    bool
+    verbose_specified () const;
+
+    void
+    verbose_specified (bool);
+
+    const bpkg::stdout_format&
+    stdout_format () const;
+
+    bpkg::stdout_format&
+    stdout_format ();
+
+    void
+    stdout_format (const bpkg::stdout_format&);
+
+    bool
+    stdout_format_specified () const;
+
+    void
+    stdout_format_specified (bool);
+
+    const size_t&
+    jobs () const;
+
+    size_t&
+    jobs ();
+
+    void
+    jobs (const size_t&);
+
+    bool
+    jobs_specified () const;
+
+    void
+    jobs_specified (bool);
+
+    const bool&
+    no_result () const;
+
+    bool&
+    no_result ();
+
+    void
+    no_result (const bool&);
+
+    const string&
+    structured_result () const;
+
+    string&
+    structured_result ();
+
+    void
+    structured_result (const string&);
+
+    bool
+    structured_result_specified () const;
+
+    void
+    structured_result_specified (bool);
+
+    const bool&
+    progress () const;
+
+    bool&
+    progress ();
+
+    void
+    progress (const bool&);
+
+    const bool&
+    no_progress () const;
+
+    bool&
+    no_progress ();
+
+    void
+    no_progress (const bool&);
+
+    const bool&
+    diag_color () const;
+
+    bool&
+    diag_color ();
+
+    void
+    diag_color (const bool&);
+
+    const bool&
+    no_diag_color () const;
+
+    bool&
+    no_diag_color ();
+
+    void
+    no_diag_color (const bool&);
+
+    const path&
+    build () const;
+
+    path&
+    build ();
+
+    void
+    build (const path&);
+
+    bool
+    build_specified () const;
+
+    void
+    build_specified (bool);
+
+    const strings&
+    build_option () const;
+
+    strings&
+    build_option ();
+
+    void
+    build_option (const strings&);
+
+    bool
+    build_option_specified () const;
+
+    void
+    build_option_specified (bool);
+
+    const path&
+    fetch () const;
+
+    path&
+    fetch ();
+
+    void
+    fetch (const path&);
+
+    bool
+    fetch_specified () const;
+
+    void
+    fetch_specified (bool);
+
+    const strings&
+    fetch_option () const;
+
+    strings&
+    fetch_option ();
+
+    void
+    fetch_option (const strings&);
+
+    bool
+    fetch_option_specified () const;
+
+    void
+    fetch_option_specified (bool);
+
+    const path&
+    curl () const;
+
+    path&
+    curl ();
+
+    void
+    curl (const path&);
+
+    bool
+    curl_specified () const;
+
+    void
+    curl_specified (bool);
+
+    const strings&
+    curl_option () const;
+
+    strings&
+    curl_option ();
+
+    void
+    curl_option (const strings&);
+
+    bool
+    curl_option_specified () const;
+
+    void
+    curl_option_specified (bool);
+
+    const size_t&
+    fetch_timeout () const;
+
+    size_t&
+    fetch_timeout ();
+
+    void
+    fetch_timeout (const size_t&);
+
+    bool
+    fetch_timeout_specified () const;
+
+    void
+    fetch_timeout_specified (bool);
+
+    const butl::url&
+    pkg_proxy () const;
+
+    butl::url&
+    pkg_proxy ();
+
+    void
+    pkg_proxy (const butl::url&);
+
+    bool
+    pkg_proxy_specified () const;
+
+    void
+    pkg_proxy_specified (bool);
+
+    const path&
+    git () const;
+
+    path&
+    git ();
+
+    void
+    git (const path&);
+
+    bool
+    git_specified () const;
+
+    void
+    git_specified (bool);
+
+    const strings&
+    git_option () const;
+
+    strings&
+    git_option ();
+
+    void
+    git_option (const strings&);
+
+    bool
+    git_option_specified () const;
+
+    void
+    git_option_specified (bool);
+
+    const path&
+    sha256 () const;
+
+    path&
+    sha256 ();
+
+    void
+    sha256 (const path&);
+
+    bool
+    sha256_specified () const;
+
+    void
+    sha256_specified (bool);
+
+    const strings&
+    sha256_option () const;
+
+    strings&
+    sha256_option ();
+
+    void
+    sha256_option (const strings&);
+
+    bool
+    sha256_option_specified () const;
+
+    void
+    sha256_option_specified (bool);
+
+    const path&
+    tar () const;
+
+    path&
+    tar ();
+
+    void
+    tar (const path&);
+
+    bool
+    tar_specified () const;
+
+    void
+    tar_specified (bool);
+
+    const strings&
+    tar_option () const;
+
+    strings&
+    tar_option ();
+
+    void
+    tar_option (const strings&);
+
+    bool
+    tar_option_specified () const;
+
+    void
+    tar_option_specified (bool);
+
+    const qualified_option<openssl_commands, path>&
+    openssl () const;
+
+    qualified_option<openssl_commands, path>&
+    openssl ();
+
+    void
+    openssl (const qualified_option<openssl_commands, path>&);
+
+    bool
+    openssl_specified () const;
+
+    void
+    openssl_specified (bool);
+
+    const qualified_option<openssl_commands, strings>&
+    openssl_option () const;
+
+    qualified_option<openssl_commands, strings>&
+    openssl_option ();
+
+    void
+    openssl_option (const qualified_option<openssl_commands, strings>&);
+
+    bool
+    openssl_option_specified () const;
+
+    void
+    openssl_option_specified (bool);
+
+    const bpkg::auth&
+    auth () const;
+
+    bpkg::auth&
+    auth ();
+
+    void
+    auth (const bpkg::auth&);
+
+    bool
+    auth_specified () const;
+
+    void
+    auth_specified (bool);
+
+    const std::set<string, icase_compare_string>&
+    trust () const;
+
+    std::set<string, icase_compare_string>&
+    trust ();
+
+    void
+    trust (const std::set<string, icase_compare_string>&);
+
+    bool
+    trust_specified () const;
+
+    void
+    trust_specified (bool);
+
+    const bool&
+    trust_yes () const;
+
+    bool&
+    trust_yes ();
+
+    void
+    trust_yes (const bool&);
+
+    const bool&
+    trust_no () const;
+
+    bool&
+    trust_no ();
+
+    void
+    trust_no (const bool&);
+
+    const git_capabilities_map&
+    git_capabilities () const;
+
+    git_capabilities_map&
+    git_capabilities ();
+
+    void
+    git_capabilities (const git_capabilities_map&);
+
+    bool
+    git_capabilities_specified () const;
+
+    void
+    git_capabilities_specified (bool);
+
+    const string&
+    pager () const;
+
+    string&
+    pager ();
+
+    void
+    pager (const string&);
+
+    bool
+    pager_specified () const;
+
+    void
+    pager_specified (bool);
+
+    const strings&
+    pager_option () const;
+
+    strings&
+    pager_option ();
+
+    void
+    pager_option (const strings&);
+
+    bool
+    pager_option_specified () const;
+
+    void
+    pager_option_specified (bool);
+
+    const string&
+    options_file () const;
+
+    string&
+    options_file ();
+
+    void
+    options_file (const string&);
+
+    bool
+    options_file_specified () const;
+
+    void
+    options_file_specified (bool);
+
+    const dir_path&
+    default_options () const;
+
+    dir_path&
+    default_options ();
+
+    void
+    default_options (const dir_path&);
+
+    bool
+    default_options_specified () const;
+
+    void
+    default_options_specified (bool);
+
+    const bool&
+    no_default_options () const;
+
+    bool&
+    no_default_options ();
+
+    void
+    no_default_options (const bool&);
+
+    const bool&
+    keep_tmp () const;
+
+    bool&
+    keep_tmp ();
+
+    void
+    keep_tmp (const bool&);
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    static ::bpkg::cli::usage_para
+    print_long_usage (::std::ostream&,
+                      ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    common_options ();
+
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    public:
+    bool v_;
+    bool V_;
+    bool quiet_;
+    uint16_t verbose_;
+    bool verbose_specified_;
+    bpkg::stdout_format stdout_format_;
+    bool stdout_format_specified_;
+    size_t jobs_;
+    bool jobs_specified_;
+    bool no_result_;
+    string structured_result_;
+    bool structured_result_specified_;
+    bool progress_;
+    bool no_progress_;
+    bool diag_color_;
+    bool no_diag_color_;
+    path build_;
+    bool build_specified_;
+    strings build_option_;
+    bool build_option_specified_;
+    path fetch_;
+    bool fetch_specified_;
+    strings fetch_option_;
+    bool fetch_option_specified_;
+    path curl_;
+    bool curl_specified_;
+    strings curl_option_;
+    bool curl_option_specified_;
+    size_t fetch_timeout_;
+    bool fetch_timeout_specified_;
+    butl::url pkg_proxy_;
+    bool pkg_proxy_specified_;
+    path git_;
+    bool git_specified_;
+    strings git_option_;
+    bool git_option_specified_;
+    path sha256_;
+    bool sha256_specified_;
+    strings sha256_option_;
+    bool sha256_option_specified_;
+    path tar_;
+    bool tar_specified_;
+    strings tar_option_;
+    bool tar_option_specified_;
+    qualified_option<openssl_commands, path> openssl_;
+    bool openssl_specified_;
+    qualified_option<openssl_commands, strings> openssl_option_;
+    bool openssl_option_specified_;
+    bpkg::auth auth_;
+    bool auth_specified_;
+    std::set<string, icase_compare_string> trust_;
+    bool trust_specified_;
+    bool trust_yes_;
+    bool trust_no_;
+    git_capabilities_map git_capabilities_;
+    bool git_capabilities_specified_;
+    string pager_;
+    bool pager_specified_;
+    strings pager_option_;
+    bool pager_option_specified_;
+    string options_file_;
+    bool options_file_specified_;
+    dir_path default_options_;
+    bool default_options_specified_;
+    bool no_default_options_;
+    bool keep_tmp_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_common_options_usage (::std::ostream&,
+                                   ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+  ::bpkg::cli::usage_para
+  print_bpkg_common_options_long_usage (::std::ostream&,
+                                        ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/common-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_COMMON_OPTIONS_HXX
diff --git a/bpkg/common-options.ixx b/bpkg/common-options.ixx
new file mode 100644
index 0000000..ed27ac3
--- /dev/null
+++ b/bpkg/common-options.ixx
@@ -0,0 +1,1436 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <cassert>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    // usage_para
+    //
+    inline usage_para::
+    usage_para (value v)
+    : v_ (v)
+    {
+    }
+
+    // unknown_mode
+    //
+    inline unknown_mode::
+    unknown_mode (value v)
+    : v_ (v)
+    {
+    }
+
+    // exception
+    //
+    inline ::std::ostream&
+    operator<< (::std::ostream& os, const exception& e)
+    {
+      e.print (os);
+      return os;
+    }
+
+    // unknown_option
+    //
+    inline unknown_option::
+    unknown_option (const std::string& option)
+    : option_ (option)
+    {
+    }
+
+    inline const std::string& unknown_option::
+    option () const
+    {
+      return option_;
+    }
+
+    // unknown_argument
+    //
+    inline unknown_argument::
+    unknown_argument (const std::string& argument)
+    : argument_ (argument)
+    {
+    }
+
+    inline const std::string& unknown_argument::
+    argument () const
+    {
+      return argument_;
+    }
+
+    // missing_value
+    //
+    inline missing_value::
+    missing_value (const std::string& option)
+    : option_ (option)
+    {
+    }
+
+    inline const std::string& missing_value::
+    option () const
+    {
+      return option_;
+    }
+
+    // invalid_value
+    //
+    inline invalid_value::
+    invalid_value (const std::string& option,
+                   const std::string& value,
+                   const std::string& message)
+    : option_ (option),
+      value_ (value),
+      message_ (message)
+    {
+    }
+
+    inline const std::string& invalid_value::
+    option () const
+    {
+      return option_;
+    }
+
+    inline const std::string& invalid_value::
+    value () const
+    {
+      return value_;
+    }
+
+    inline const std::string& invalid_value::
+    message () const
+    {
+      return message_;
+    }
+
+    // file_io_failure
+    //
+    inline file_io_failure::
+    file_io_failure (const std::string& file)
+    : file_ (file)
+    {
+    }
+
+    inline const std::string& file_io_failure::
+    file () const
+    {
+      return file_;
+    }
+
+    // unmatched_quote
+    //
+    inline unmatched_quote::
+    unmatched_quote (const std::string& argument)
+    : argument_ (argument)
+    {
+    }
+
+    inline const std::string& unmatched_quote::
+    argument () const
+    {
+      return argument_;
+    }
+
+    // unexpected_group
+    //
+    inline unexpected_group::
+    unexpected_group (const std::string& argument,
+                      const std::string& group)
+    : argument_ (argument), group_ (group)
+    {
+    }
+
+    inline const std::string& unexpected_group::
+    argument () const
+    {
+      return argument_;
+    }
+
+    inline const std::string& unexpected_group::
+    group () const
+    {
+      return group_;
+    }
+
+    // group_separator
+    //
+    inline group_separator::
+    group_separator (const std::string& encountered,
+                     const std::string& expected)
+    : encountered_ (encountered), expected_ (expected)
+    {
+    }
+
+    inline const std::string& group_separator::
+    encountered () const
+    {
+      return encountered_;
+    }
+
+    inline const std::string& group_separator::
+    expected () const
+    {
+      return expected_;
+    }
+
+    // argv_scanner
+    //
+    inline argv_scanner::
+    argv_scanner (int& argc,
+                  char** argv,
+                  bool erase,
+                  std::size_t sp)
+    : start_position_ (sp + 1),
+      i_ (1),
+      argc_ (argc),
+      argv_ (argv),
+      erase_ (erase)
+    {
+    }
+
+    inline argv_scanner::
+    argv_scanner (int start,
+                  int& argc,
+                  char** argv,
+                  bool erase,
+                  std::size_t sp)
+    : start_position_ (sp + static_cast<std::size_t> (start)),
+      i_ (start),
+      argc_ (argc),
+      argv_ (argv),
+      erase_ (erase)
+    {
+    }
+
+    inline int argv_scanner::
+    end () const
+    {
+      return i_;
+    }
+
+    // vector_scanner
+    //
+    inline vector_scanner::
+    vector_scanner (const std::vector<std::string>& v,
+                    std::size_t i,
+                    std::size_t sp)
+    : start_position_ (sp), v_ (v), i_ (i)
+    {
+    }
+
+    inline std::size_t vector_scanner::
+    end () const
+    {
+      return i_;
+    }
+
+    inline void vector_scanner::
+    reset (std::size_t i, std::size_t sp)
+    {
+      i_ = i;
+      start_position_ = sp;
+    }
+
+    // argv_file_scanner
+    //
+    inline argv_file_scanner::
+    argv_file_scanner (int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase,
+                       std::size_t sp)
+    : argv_scanner (argc, argv, erase, sp),
+      option_ (option),
+      options_ (&option_info_),
+      options_count_ (1),
+      i_ (1),
+      skip_ (false)
+    {
+      option_info_.option = option_.c_str ();
+      option_info_.search_func = 0;
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const std::string& option,
+                       bool erase,
+                       std::size_t sp)
+    : argv_scanner (start, argc, argv, erase, sp),
+      option_ (option),
+      options_ (&option_info_),
+      options_count_ (1),
+      i_ (1),
+      skip_ (false)
+    {
+      option_info_.option = option_.c_str ();
+      option_info_.search_func = 0;
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (const std::string& file,
+                       const std::string& option,
+                       std::size_t sp)
+    : argv_scanner (0, zero_argc_, 0, sp),
+      option_ (option),
+      options_ (&option_info_),
+      options_count_ (1),
+      i_ (1),
+      skip_ (false)
+    {
+      option_info_.option = option_.c_str ();
+      option_info_.search_func = 0;
+
+      load (file);
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (int& argc,
+                       char** argv,
+                       const option_info* options,
+                       std::size_t options_count,
+                       bool erase,
+                       std::size_t sp)
+    : argv_scanner (argc, argv, erase, sp),
+      options_ (options),
+      options_count_ (options_count),
+      i_ (1),
+      skip_ (false)
+    {
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (int start,
+                       int& argc,
+                       char** argv,
+                       const option_info* options,
+                       std::size_t options_count,
+                       bool erase,
+                       std::size_t sp)
+    : argv_scanner (start, argc, argv, erase, sp),
+      options_ (options),
+      options_count_ (options_count),
+      i_ (1),
+      skip_ (false)
+    {
+    }
+
+    inline argv_file_scanner::
+    argv_file_scanner (const std::string& file,
+                       const option_info* options,
+                       std::size_t options_count,
+                       std::size_t sp)
+    : argv_scanner (0, zero_argc_, 0, sp),
+      options_ (options),
+      options_count_ (options_count),
+      i_ (1),
+      skip_ (false)
+    {
+      load (file);
+    }
+
+    // group_scanner
+    //
+    inline group_scanner::
+    group_scanner (scanner& s)
+    : scan_ (s), state_ (skipped), i_ (1), j_ (0), group_scan_ (group_)
+    {
+    }
+
+    inline scanner& group_scanner::
+    group ()
+    {
+      assert (state_ == scanned || state_ == skipped);
+      return group_scan_;
+    }
+
+    inline const char* group_scanner::
+    escape (const char* a)
+    {
+      switch (sense (a))
+      {
+        case separator::none:       break;
+        case separator::open:       return "\\{";
+        case separator::close:      return "\\}";
+        case separator::open_plus:  return "\\+{";
+        case separator::close_plus: return "\\}+";
+      }
+
+      return a;
+    }
+
+    inline group_scanner::separator group_scanner::
+    sense (const char* s)
+    {
+      switch (s[0])
+      {
+        case '{': return s[1] == '\0' ? open  : none;
+        case '}':
+        {
+          switch (s[1])
+          {
+            case '+': return s[2] == '\0' ? close_plus  : none;
+            default:  return s[1] == '\0' ? close       : none;
+          }
+        }
+        case '+':
+        {
+          switch (s[1])
+          {
+            case '{': return s[2] == '\0' ? open_plus  : none;
+            default:  return                             none;
+          }
+        }
+      }
+
+      return none;
+    }
+  }
+}
+
+namespace bpkg
+{
+  // common_options
+  //
+
+  inline const bool& common_options::
+  v () const
+  {
+    return this->v_;
+  }
+
+  inline bool& common_options::
+  v ()
+  {
+    return this->v_;
+  }
+
+  inline void common_options::
+  v (const bool& x)
+  {
+    this->v_ = x;
+  }
+
+  inline const bool& common_options::
+  V () const
+  {
+    return this->V_;
+  }
+
+  inline bool& common_options::
+  V ()
+  {
+    return this->V_;
+  }
+
+  inline void common_options::
+  V (const bool& x)
+  {
+    this->V_ = x;
+  }
+
+  inline const bool& common_options::
+  quiet () const
+  {
+    return this->quiet_;
+  }
+
+  inline bool& common_options::
+  quiet ()
+  {
+    return this->quiet_;
+  }
+
+  inline void common_options::
+  quiet (const bool& x)
+  {
+    this->quiet_ = x;
+  }
+
+  inline const uint16_t& common_options::
+  verbose () const
+  {
+    return this->verbose_;
+  }
+
+  inline uint16_t& common_options::
+  verbose ()
+  {
+    return this->verbose_;
+  }
+
+  inline void common_options::
+  verbose (const uint16_t& x)
+  {
+    this->verbose_ = x;
+  }
+
+  inline bool common_options::
+  verbose_specified () const
+  {
+    return this->verbose_specified_;
+  }
+
+  inline void common_options::
+  verbose_specified (bool x)
+  {
+    this->verbose_specified_ = x;
+  }
+
+  inline const bpkg::stdout_format& common_options::
+  stdout_format () const
+  {
+    return this->stdout_format_;
+  }
+
+  inline bpkg::stdout_format& common_options::
+  stdout_format ()
+  {
+    return this->stdout_format_;
+  }
+
+  inline void common_options::
+  stdout_format (const bpkg::stdout_format& x)
+  {
+    this->stdout_format_ = x;
+  }
+
+  inline bool common_options::
+  stdout_format_specified () const
+  {
+    return this->stdout_format_specified_;
+  }
+
+  inline void common_options::
+  stdout_format_specified (bool x)
+  {
+    this->stdout_format_specified_ = x;
+  }
+
+  inline const size_t& common_options::
+  jobs () const
+  {
+    return this->jobs_;
+  }
+
+  inline size_t& common_options::
+  jobs ()
+  {
+    return this->jobs_;
+  }
+
+  inline void common_options::
+  jobs (const size_t& x)
+  {
+    this->jobs_ = x;
+  }
+
+  inline bool common_options::
+  jobs_specified () const
+  {
+    return this->jobs_specified_;
+  }
+
+  inline void common_options::
+  jobs_specified (bool x)
+  {
+    this->jobs_specified_ = x;
+  }
+
+  inline const bool& common_options::
+  no_result () const
+  {
+    return this->no_result_;
+  }
+
+  inline bool& common_options::
+  no_result ()
+  {
+    return this->no_result_;
+  }
+
+  inline void common_options::
+  no_result (const bool& x)
+  {
+    this->no_result_ = x;
+  }
+
+  inline const string& common_options::
+  structured_result () const
+  {
+    return this->structured_result_;
+  }
+
+  inline string& common_options::
+  structured_result ()
+  {
+    return this->structured_result_;
+  }
+
+  inline void common_options::
+  structured_result (const string& x)
+  {
+    this->structured_result_ = x;
+  }
+
+  inline bool common_options::
+  structured_result_specified () const
+  {
+    return this->structured_result_specified_;
+  }
+
+  inline void common_options::
+  structured_result_specified (bool x)
+  {
+    this->structured_result_specified_ = x;
+  }
+
+  inline const bool& common_options::
+  progress () const
+  {
+    return this->progress_;
+  }
+
+  inline bool& common_options::
+  progress ()
+  {
+    return this->progress_;
+  }
+
+  inline void common_options::
+  progress (const bool& x)
+  {
+    this->progress_ = x;
+  }
+
+  inline const bool& common_options::
+  no_progress () const
+  {
+    return this->no_progress_;
+  }
+
+  inline bool& common_options::
+  no_progress ()
+  {
+    return this->no_progress_;
+  }
+
+  inline void common_options::
+  no_progress (const bool& x)
+  {
+    this->no_progress_ = x;
+  }
+
+  inline const bool& common_options::
+  diag_color () const
+  {
+    return this->diag_color_;
+  }
+
+  inline bool& common_options::
+  diag_color ()
+  {
+    return this->diag_color_;
+  }
+
+  inline void common_options::
+  diag_color (const bool& x)
+  {
+    this->diag_color_ = x;
+  }
+
+  inline const bool& common_options::
+  no_diag_color () const
+  {
+    return this->no_diag_color_;
+  }
+
+  inline bool& common_options::
+  no_diag_color ()
+  {
+    return this->no_diag_color_;
+  }
+
+  inline void common_options::
+  no_diag_color (const bool& x)
+  {
+    this->no_diag_color_ = x;
+  }
+
+  inline const path& common_options::
+  build () const
+  {
+    return this->build_;
+  }
+
+  inline path& common_options::
+  build ()
+  {
+    return this->build_;
+  }
+
+  inline void common_options::
+  build (const path& x)
+  {
+    this->build_ = x;
+  }
+
+  inline bool common_options::
+  build_specified () const
+  {
+    return this->build_specified_;
+  }
+
+  inline void common_options::
+  build_specified (bool x)
+  {
+    this->build_specified_ = x;
+  }
+
+  inline const strings& common_options::
+  build_option () const
+  {
+    return this->build_option_;
+  }
+
+  inline strings& common_options::
+  build_option ()
+  {
+    return this->build_option_;
+  }
+
+  inline void common_options::
+  build_option (const strings& x)
+  {
+    this->build_option_ = x;
+  }
+
+  inline bool common_options::
+  build_option_specified () const
+  {
+    return this->build_option_specified_;
+  }
+
+  inline void common_options::
+  build_option_specified (bool x)
+  {
+    this->build_option_specified_ = x;
+  }
+
+  inline const path& common_options::
+  fetch () const
+  {
+    return this->fetch_;
+  }
+
+  inline path& common_options::
+  fetch ()
+  {
+    return this->fetch_;
+  }
+
+  inline void common_options::
+  fetch (const path& x)
+  {
+    this->fetch_ = x;
+  }
+
+  inline bool common_options::
+  fetch_specified () const
+  {
+    return this->fetch_specified_;
+  }
+
+  inline void common_options::
+  fetch_specified (bool x)
+  {
+    this->fetch_specified_ = x;
+  }
+
+  inline const strings& common_options::
+  fetch_option () const
+  {
+    return this->fetch_option_;
+  }
+
+  inline strings& common_options::
+  fetch_option ()
+  {
+    return this->fetch_option_;
+  }
+
+  inline void common_options::
+  fetch_option (const strings& x)
+  {
+    this->fetch_option_ = x;
+  }
+
+  inline bool common_options::
+  fetch_option_specified () const
+  {
+    return this->fetch_option_specified_;
+  }
+
+  inline void common_options::
+  fetch_option_specified (bool x)
+  {
+    this->fetch_option_specified_ = x;
+  }
+
+  inline const path& common_options::
+  curl () const
+  {
+    return this->curl_;
+  }
+
+  inline path& common_options::
+  curl ()
+  {
+    return this->curl_;
+  }
+
+  inline void common_options::
+  curl (const path& x)
+  {
+    this->curl_ = x;
+  }
+
+  inline bool common_options::
+  curl_specified () const
+  {
+    return this->curl_specified_;
+  }
+
+  inline void common_options::
+  curl_specified (bool x)
+  {
+    this->curl_specified_ = x;
+  }
+
+  inline const strings& common_options::
+  curl_option () const
+  {
+    return this->curl_option_;
+  }
+
+  inline strings& common_options::
+  curl_option ()
+  {
+    return this->curl_option_;
+  }
+
+  inline void common_options::
+  curl_option (const strings& x)
+  {
+    this->curl_option_ = x;
+  }
+
+  inline bool common_options::
+  curl_option_specified () const
+  {
+    return this->curl_option_specified_;
+  }
+
+  inline void common_options::
+  curl_option_specified (bool x)
+  {
+    this->curl_option_specified_ = x;
+  }
+
+  inline const size_t& common_options::
+  fetch_timeout () const
+  {
+    return this->fetch_timeout_;
+  }
+
+  inline size_t& common_options::
+  fetch_timeout ()
+  {
+    return this->fetch_timeout_;
+  }
+
+  inline void common_options::
+  fetch_timeout (const size_t& x)
+  {
+    this->fetch_timeout_ = x;
+  }
+
+  inline bool common_options::
+  fetch_timeout_specified () const
+  {
+    return this->fetch_timeout_specified_;
+  }
+
+  inline void common_options::
+  fetch_timeout_specified (bool x)
+  {
+    this->fetch_timeout_specified_ = x;
+  }
+
+  inline const butl::url& common_options::
+  pkg_proxy () const
+  {
+    return this->pkg_proxy_;
+  }
+
+  inline butl::url& common_options::
+  pkg_proxy ()
+  {
+    return this->pkg_proxy_;
+  }
+
+  inline void common_options::
+  pkg_proxy (const butl::url& x)
+  {
+    this->pkg_proxy_ = x;
+  }
+
+  inline bool common_options::
+  pkg_proxy_specified () const
+  {
+    return this->pkg_proxy_specified_;
+  }
+
+  inline void common_options::
+  pkg_proxy_specified (bool x)
+  {
+    this->pkg_proxy_specified_ = x;
+  }
+
+  inline const path& common_options::
+  git () const
+  {
+    return this->git_;
+  }
+
+  inline path& common_options::
+  git ()
+  {
+    return this->git_;
+  }
+
+  inline void common_options::
+  git (const path& x)
+  {
+    this->git_ = x;
+  }
+
+  inline bool common_options::
+  git_specified () const
+  {
+    return this->git_specified_;
+  }
+
+  inline void common_options::
+  git_specified (bool x)
+  {
+    this->git_specified_ = x;
+  }
+
+  inline const strings& common_options::
+  git_option () const
+  {
+    return this->git_option_;
+  }
+
+  inline strings& common_options::
+  git_option ()
+  {
+    return this->git_option_;
+  }
+
+  inline void common_options::
+  git_option (const strings& x)
+  {
+    this->git_option_ = x;
+  }
+
+  inline bool common_options::
+  git_option_specified () const
+  {
+    return this->git_option_specified_;
+  }
+
+  inline void common_options::
+  git_option_specified (bool x)
+  {
+    this->git_option_specified_ = x;
+  }
+
+  inline const path& common_options::
+  sha256 () const
+  {
+    return this->sha256_;
+  }
+
+  inline path& common_options::
+  sha256 ()
+  {
+    return this->sha256_;
+  }
+
+  inline void common_options::
+  sha256 (const path& x)
+  {
+    this->sha256_ = x;
+  }
+
+  inline bool common_options::
+  sha256_specified () const
+  {
+    return this->sha256_specified_;
+  }
+
+  inline void common_options::
+  sha256_specified (bool x)
+  {
+    this->sha256_specified_ = x;
+  }
+
+  inline const strings& common_options::
+  sha256_option () const
+  {
+    return this->sha256_option_;
+  }
+
+  inline strings& common_options::
+  sha256_option ()
+  {
+    return this->sha256_option_;
+  }
+
+  inline void common_options::
+  sha256_option (const strings& x)
+  {
+    this->sha256_option_ = x;
+  }
+
+  inline bool common_options::
+  sha256_option_specified () const
+  {
+    return this->sha256_option_specified_;
+  }
+
+  inline void common_options::
+  sha256_option_specified (bool x)
+  {
+    this->sha256_option_specified_ = x;
+  }
+
+  inline const path& common_options::
+  tar () const
+  {
+    return this->tar_;
+  }
+
+  inline path& common_options::
+  tar ()
+  {
+    return this->tar_;
+  }
+
+  inline void common_options::
+  tar (const path& x)
+  {
+    this->tar_ = x;
+  }
+
+  inline bool common_options::
+  tar_specified () const
+  {
+    return this->tar_specified_;
+  }
+
+  inline void common_options::
+  tar_specified (bool x)
+  {
+    this->tar_specified_ = x;
+  }
+
+  inline const strings& common_options::
+  tar_option () const
+  {
+    return this->tar_option_;
+  }
+
+  inline strings& common_options::
+  tar_option ()
+  {
+    return this->tar_option_;
+  }
+
+  inline void common_options::
+  tar_option (const strings& x)
+  {
+    this->tar_option_ = x;
+  }
+
+  inline bool common_options::
+  tar_option_specified () const
+  {
+    return this->tar_option_specified_;
+  }
+
+  inline void common_options::
+  tar_option_specified (bool x)
+  {
+    this->tar_option_specified_ = x;
+  }
+
+  inline const qualified_option<openssl_commands, path>& common_options::
+  openssl () const
+  {
+    return this->openssl_;
+  }
+
+  inline qualified_option<openssl_commands, path>& common_options::
+  openssl ()
+  {
+    return this->openssl_;
+  }
+
+  inline void common_options::
+  openssl (const qualified_option<openssl_commands, path>& x)
+  {
+    this->openssl_ = x;
+  }
+
+  inline bool common_options::
+  openssl_specified () const
+  {
+    return this->openssl_specified_;
+  }
+
+  inline void common_options::
+  openssl_specified (bool x)
+  {
+    this->openssl_specified_ = x;
+  }
+
+  inline const qualified_option<openssl_commands, strings>& common_options::
+  openssl_option () const
+  {
+    return this->openssl_option_;
+  }
+
+  inline qualified_option<openssl_commands, strings>& common_options::
+  openssl_option ()
+  {
+    return this->openssl_option_;
+  }
+
+  inline void common_options::
+  openssl_option (const qualified_option<openssl_commands, strings>& x)
+  {
+    this->openssl_option_ = x;
+  }
+
+  inline bool common_options::
+  openssl_option_specified () const
+  {
+    return this->openssl_option_specified_;
+  }
+
+  inline void common_options::
+  openssl_option_specified (bool x)
+  {
+    this->openssl_option_specified_ = x;
+  }
+
+  inline const bpkg::auth& common_options::
+  auth () const
+  {
+    return this->auth_;
+  }
+
+  inline bpkg::auth& common_options::
+  auth ()
+  {
+    return this->auth_;
+  }
+
+  inline void common_options::
+  auth (const bpkg::auth& x)
+  {
+    this->auth_ = x;
+  }
+
+  inline bool common_options::
+  auth_specified () const
+  {
+    return this->auth_specified_;
+  }
+
+  inline void common_options::
+  auth_specified (bool x)
+  {
+    this->auth_specified_ = x;
+  }
+
+  inline const std::set<string, icase_compare_string>& common_options::
+  trust () const
+  {
+    return this->trust_;
+  }
+
+  inline std::set<string, icase_compare_string>& common_options::
+  trust ()
+  {
+    return this->trust_;
+  }
+
+  inline void common_options::
+  trust (const std::set<string, icase_compare_string>& x)
+  {
+    this->trust_ = x;
+  }
+
+  inline bool common_options::
+  trust_specified () const
+  {
+    return this->trust_specified_;
+  }
+
+  inline void common_options::
+  trust_specified (bool x)
+  {
+    this->trust_specified_ = x;
+  }
+
+  inline const bool& common_options::
+  trust_yes () const
+  {
+    return this->trust_yes_;
+  }
+
+  inline bool& common_options::
+  trust_yes ()
+  {
+    return this->trust_yes_;
+  }
+
+  inline void common_options::
+  trust_yes (const bool& x)
+  {
+    this->trust_yes_ = x;
+  }
+
+  inline const bool& common_options::
+  trust_no () const
+  {
+    return this->trust_no_;
+  }
+
+  inline bool& common_options::
+  trust_no ()
+  {
+    return this->trust_no_;
+  }
+
+  inline void common_options::
+  trust_no (const bool& x)
+  {
+    this->trust_no_ = x;
+  }
+
+  inline const git_capabilities_map& common_options::
+  git_capabilities () const
+  {
+    return this->git_capabilities_;
+  }
+
+  inline git_capabilities_map& common_options::
+  git_capabilities ()
+  {
+    return this->git_capabilities_;
+  }
+
+  inline void common_options::
+  git_capabilities (const git_capabilities_map& x)
+  {
+    this->git_capabilities_ = x;
+  }
+
+  inline bool common_options::
+  git_capabilities_specified () const
+  {
+    return this->git_capabilities_specified_;
+  }
+
+  inline void common_options::
+  git_capabilities_specified (bool x)
+  {
+    this->git_capabilities_specified_ = x;
+  }
+
+  inline const string& common_options::
+  pager () const
+  {
+    return this->pager_;
+  }
+
+  inline string& common_options::
+  pager ()
+  {
+    return this->pager_;
+  }
+
+  inline void common_options::
+  pager (const string& x)
+  {
+    this->pager_ = x;
+  }
+
+  inline bool common_options::
+  pager_specified () const
+  {
+    return this->pager_specified_;
+  }
+
+  inline void common_options::
+  pager_specified (bool x)
+  {
+    this->pager_specified_ = x;
+  }
+
+  inline const strings& common_options::
+  pager_option () const
+  {
+    return this->pager_option_;
+  }
+
+  inline strings& common_options::
+  pager_option ()
+  {
+    return this->pager_option_;
+  }
+
+  inline void common_options::
+  pager_option (const strings& x)
+  {
+    this->pager_option_ = x;
+  }
+
+  inline bool common_options::
+  pager_option_specified () const
+  {
+    return this->pager_option_specified_;
+  }
+
+  inline void common_options::
+  pager_option_specified (bool x)
+  {
+    this->pager_option_specified_ = x;
+  }
+
+  inline const string& common_options::
+  options_file () const
+  {
+    return this->options_file_;
+  }
+
+  inline string& common_options::
+  options_file ()
+  {
+    return this->options_file_;
+  }
+
+  inline void common_options::
+  options_file (const string& x)
+  {
+    this->options_file_ = x;
+  }
+
+  inline bool common_options::
+  options_file_specified () const
+  {
+    return this->options_file_specified_;
+  }
+
+  inline void common_options::
+  options_file_specified (bool x)
+  {
+    this->options_file_specified_ = x;
+  }
+
+  inline const dir_path& common_options::
+  default_options () const
+  {
+    return this->default_options_;
+  }
+
+  inline dir_path& common_options::
+  default_options ()
+  {
+    return this->default_options_;
+  }
+
+  inline void common_options::
+  default_options (const dir_path& x)
+  {
+    this->default_options_ = x;
+  }
+
+  inline bool common_options::
+  default_options_specified () const
+  {
+    return this->default_options_specified_;
+  }
+
+  inline void common_options::
+  default_options_specified (bool x)
+  {
+    this->default_options_specified_ = x;
+  }
+
+  inline const bool& common_options::
+  no_default_options () const
+  {
+    return this->no_default_options_;
+  }
+
+  inline bool& common_options::
+  no_default_options ()
+  {
+    return this->no_default_options_;
+  }
+
+  inline void common_options::
+  no_default_options (const bool& x)
+  {
+    this->no_default_options_ = x;
+  }
+
+  inline const bool& common_options::
+  keep_tmp () const
+  {
+    return this->keep_tmp_;
+  }
+
+  inline bool& common_options::
+  keep_tmp ()
+  {
+    return this->keep_tmp_;
+  }
+
+  inline void common_options::
+  keep_tmp (const bool& x)
+  {
+    this->keep_tmp_ = x;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/configuration-options.cxx b/bpkg/configuration-options.cxx
new file mode 100644
index 0000000..9790132
--- /dev/null
+++ b/bpkg/configuration-options.cxx
@@ -0,0 +1,653 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // configuration_options
+  //
+
+  configuration_options::
+  configuration_options ()
+  : directory_ ("."),
+    directory_specified_ (false)
+  {
+  }
+
+  bool configuration_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool configuration_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool configuration_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool configuration_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool configuration_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void configuration_options::
+  merge (const configuration_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+
+    if (a.directory_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->directory_, a.directory_);
+      this->directory_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para configuration_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1m--directory\033[0m|\033[1m-d\033[0m \033[4mdir\033[0m        Assume configuration is in \033[4mdir\033[0m rather than in the" << ::std::endl
+       << "                          current working directory." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (configuration_options&, ::bpkg::cli::scanner&)>
+  _cli_configuration_options_map;
+
+  static _cli_configuration_options_map _cli_configuration_options_map_;
+
+  struct _cli_configuration_options_map_init
+  {
+    _cli_configuration_options_map_init ()
+    {
+      _cli_configuration_options_map_["--directory"] =
+      &::bpkg::cli::thunk< configuration_options, dir_path, &configuration_options::directory_,
+        &configuration_options::directory_specified_ >;
+      _cli_configuration_options_map_["-d"] =
+      &::bpkg::cli::thunk< configuration_options, dir_path, &configuration_options::directory_,
+        &configuration_options::directory_specified_ >;
+    }
+  };
+
+  static _cli_configuration_options_map_init _cli_configuration_options_map_init_;
+
+  bool configuration_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_configuration_options_map::const_iterator i (_cli_configuration_options_map_.find (o));
+
+    if (i != _cli_configuration_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool configuration_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_configuration_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/configuration-options.hxx b/bpkg/configuration-options.hxx
new file mode 100644
index 0000000..d7a61db
--- /dev/null
+++ b/bpkg/configuration-options.hxx
@@ -0,0 +1,117 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_CONFIGURATION_OPTIONS_HXX
+#define BPKG_CONFIGURATION_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class configuration_options: public ::bpkg::common_options
+  {
+    public:
+    configuration_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const configuration_options&);
+
+    // Option accessors.
+    //
+    const dir_path&
+    directory () const;
+
+    bool
+    directory_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    dir_path directory_;
+    bool directory_specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_configuration_usage (::std::ostream&,
+                             ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/configuration-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_CONFIGURATION_OPTIONS_HXX
diff --git a/bpkg/configuration-options.ixx b/bpkg/configuration-options.ixx
new file mode 100644
index 0000000..294a431
--- /dev/null
+++ b/bpkg/configuration-options.ixx
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // configuration_options
+  //
+
+  inline const dir_path& configuration_options::
+  directory () const
+  {
+    return this->directory_;
+  }
+
+  inline bool configuration_options::
+  directory_specified () const
+  {
+    return this->directory_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/default-options-files.cxx b/bpkg/default-options-files.cxx
new file mode 100644
index 0000000..72c5745
--- /dev/null
+++ b/bpkg/default-options-files.cxx
@@ -0,0 +1,91 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/default-options-files.hxx>
+
+#include <map>
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_default_options_files_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg\033[0m \033[4mcommand\033[0m [\033[4mmode-options\033[0m] ...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "Instead of having a separate config file format for tool configuration, the" << ::std::endl
+       << "\033[1mbuild2\033[0m toolchain uses \033[4mdefault options files\033[0m which contain the same options as" << ::std::endl
+       << "what can be specified on the command line. The default options files are like" << ::std::endl
+       << "options files that one can specify with \033[1m--options-file\033[0m (\033[1mbpkg-common-options(1)\033[0m)" << ::std::endl
+       << "except that they are loaded by default." << ::std::endl
+       << ::std::endl
+       << "The default options files are searched for in the \033[1m.build2/\033[0m and \033[1m.build2/local/\033[0m" << ::std::endl
+       << "subdirectories of each outer directory beginning from the \033[4mstart directory\033[0m and" << ::std::endl
+       << "until reaching either the home directory or the filesystem root directory (both" << ::std::endl
+       << "excluding). Then in the \033[1m.build2/\033[0m subdirectory of the home directory and finally" << ::std::endl
+       << "in the system directory (for example, \033[1m/etc/build2/\033[0m) if configured." << ::std::endl
+       << ::std::endl
+       << "Once the search is complete, the files are loaded in the reverse order, that" << ::std::endl
+       << "is, beginning from the system directory (if any), followed by the home" << ::std::endl
+       << "directory, ending with the start directory, and finishing off with the options" << ::std::endl
+       << "specified on the command line.  In other words, the files are loaded from the" << ::std::endl
+       << "more generic to the more specific with the command line options having the" << ::std::endl
+       << "ability to override any values specified in the default options files." << ::std::endl
+       << ::std::endl
+       << "The start directory, the names of the default options files, and in which order" << ::std::endl
+       << "they are loaded within each directory are determined by the \033[4mcommand\033[0m and" << ::std::endl
+       << "potentially its \033[4mmode-options\033[0m. See each command's DEFAULT OPTIONS FILES section" << ::std::endl
+       << "for details." << ::std::endl
+       << ::std::endl
+       << "If a default options file contains \033[1m--no-default-options\033[0m, then the search is" << ::std::endl
+       << "stopped at the directory containing this file and no outer files are loaded. If" << ::std::endl
+       << "this option is specified on the command line, then none of the default options" << ::std::endl
+       << "files are searched for or loaded." << ::std::endl
+       << ::std::endl
+       << "An additional directory containing default options files can be specified with" << ::std::endl
+       << "\033[1m--default-options\033[0m. If such a directory is a subdirectory of the start directory" << ::std::endl
+       << "or is between the start directory and the end of the outer search, then its" << ::std::endl
+       << "configuration files are loaded at the corresponding point in the directory" << ::std::endl
+       << "hierarchy. Otherwise, they are loaded after the home directory." << ::std::endl
+       << ::std::endl
+       << "The presence of the \033[1m.git\033[0m filesystem entry causes the default options files in" << ::std::endl
+       << "this directory and any of its subdirectories to be considered remote. Depending" << ::std::endl
+       << "on the command, some security-sensitive options may be disallowed or trigger a" << ::std::endl
+       << "prompt when specified in remote options files (in the current implementation" << ::std::endl
+       << "this is the case even for files from the \033[1m.build2/local/\033[0m subdirectory since the" << ::std::endl
+       << "mere location is not a sufficient ground to definitively conclude that the file" << ::std::endl
+       << "is not remote; to be sure we would need to query the version control system)." << ::std::endl
+       << "Note that additional default options files specified with \033[1m--default-options\033[0m are" << ::std::endl
+       << "never considered remote." << ::std::endl
+       << ::std::endl
+       << "The order in which default options files are loaded is traced at the verbosity" << ::std::endl
+       << "level 3 (\033[1m-V\033[0m option) or higher." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/default-options-files.hxx b/bpkg/default-options-files.hxx
new file mode 100644
index 0000000..a26c600
--- /dev/null
+++ b/bpkg/default-options-files.hxx
@@ -0,0 +1,31 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_DEFAULT_OPTIONS_FILES_HXX
+#define BPKG_DEFAULT_OPTIONS_FILES_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_default_options_files_usage (::std::ostream&,
+                                          ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_DEFAULT_OPTIONS_FILES_HXX
diff --git a/bpkg/help-options.cxx b/bpkg/help-options.cxx
new file mode 100644
index 0000000..4a7244e
--- /dev/null
+++ b/bpkg/help-options.cxx
@@ -0,0 +1,657 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/help-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // help_options
+  //
+
+  help_options::
+  help_options ()
+  {
+  }
+
+  bool help_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool help_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool help_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool help_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool help_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void help_options::
+  merge (const help_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+  }
+
+  ::bpkg::cli::usage_para help_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (help_options&, ::bpkg::cli::scanner&)>
+  _cli_help_options_map;
+
+  static _cli_help_options_map _cli_help_options_map_;
+
+  struct _cli_help_options_map_init
+  {
+    _cli_help_options_map_init ()
+    {
+    }
+  };
+
+  static _cli_help_options_map_init _cli_help_options_map_init_;
+
+  bool help_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_help_options_map::const_iterator i (_cli_help_options_map_.find (o));
+
+    if (i != _cli_help_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool help_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_help_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg help\033[0m [\033[4mcommand\033[0m | \033[4mtopic\033[0m]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "Show the detailed help for \033[4mcommand\033[0m or help \033[4mtopic\033[0m or a summary of available" << ::std::endl
+       << "commands and topics if none was specified." << ::std::endl;
+
+    p = ::bpkg::help_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mhelp\033[0m command the following options files are searched for only in the" << ::std::endl
+       << "predefined directories (home, system, etc) and, if found, loaded in the order" << ::std::endl
+       << "listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-help.options" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/help-options.hxx b/bpkg/help-options.hxx
new file mode 100644
index 0000000..9c67dee
--- /dev/null
+++ b/bpkg/help-options.hxx
@@ -0,0 +1,109 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_HELP_OPTIONS_HXX
+#define BPKG_HELP_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class help_options: public ::bpkg::common_options
+  {
+    public:
+    help_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const help_options&);
+
+    // Option accessors.
+    //
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_help_usage (::std::ostream&,
+                         ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/help-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_HELP_OPTIONS_HXX
diff --git a/bpkg/help-options.ixx b/bpkg/help-options.ixx
new file mode 100644
index 0000000..91f5bfd
--- /dev/null
+++ b/bpkg/help-options.ixx
@@ -0,0 +1,21 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // help_options
+  //
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/package-odb.cxx b/bpkg/package-odb.cxx
new file mode 100644
index 0000000..aa7e156
--- /dev/null
+++ b/bpkg/package-odb.cxx
@@ -0,0 +1,19100 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#include <odb/pre.hxx>
+
+#include <bpkg/package-odb.hxx>
+
+#include <cassert>
+#include <cstring>  // std::memcpy
+
+#include <odb/schema-catalog-impl.hxx>
+
+#include <odb/sqlite/traits.hxx>
+#include <odb/sqlite/database.hxx>
+#include <odb/sqlite/transaction.hxx>
+#include <odb/sqlite/connection.hxx>
+#include <odb/sqlite/statement.hxx>
+#include <odb/sqlite/statement-cache.hxx>
+#include <odb/sqlite/simple-object-statements.hxx>
+#include <odb/sqlite/view-statements.hxx>
+#include <odb/sqlite/section-statements.hxx>
+#include <odb/sqlite/container-statements.hxx>
+#include <odb/sqlite/exceptions.hxx>
+#include <odb/sqlite/prepared-query.hxx>
+#include <odb/sqlite/simple-object-result.hxx>
+#include <odb/sqlite/view-result.hxx>
+
+namespace odb
+{
+  // _version
+  //
+
+  bool access::composite_value_traits< ::bpkg::_version, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // epoch
+    //
+    t[0UL] = false;
+
+    // canonical_upstream
+    //
+    if (t[1UL])
+    {
+      i.canonical_upstream_value.capacity (i.canonical_upstream_size);
+      grew = true;
+    }
+
+    // canonical_release
+    //
+    if (t[2UL])
+    {
+      i.canonical_release_value.capacity (i.canonical_release_size);
+      grew = true;
+    }
+
+    // revision
+    //
+    t[3UL] = false;
+
+    // iteration
+    //
+    t[4UL] = false;
+
+    // upstream
+    //
+    if (t[5UL])
+    {
+      i.upstream_value.capacity (i.upstream_size);
+      grew = true;
+    }
+
+    // release
+    //
+    if (t[6UL])
+    {
+      i.release_value.capacity (i.release_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::_version, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // epoch
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.epoch_value;
+    b[n].is_null = &i.epoch_null;
+    n++;
+
+    // canonical_upstream
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.canonical_upstream_value.data ();
+    b[n].size = &i.canonical_upstream_size;
+    b[n].capacity = i.canonical_upstream_value.capacity ();
+    b[n].is_null = &i.canonical_upstream_null;
+    n++;
+
+    // canonical_release
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.canonical_release_value.data ();
+    b[n].size = &i.canonical_release_size;
+    b[n].capacity = i.canonical_release_value.capacity ();
+    b[n].is_null = &i.canonical_release_null;
+    n++;
+
+    // revision
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.revision_value;
+    b[n].is_null = &i.revision_null;
+    n++;
+
+    // iteration
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.iteration_value;
+    b[n].is_null = &i.iteration_null;
+    n++;
+
+    // upstream
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.upstream_value.data ();
+    b[n].size = &i.upstream_size;
+    b[n].capacity = i.upstream_value.capacity ();
+    b[n].is_null = &i.upstream_null;
+    n++;
+
+    // release
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.release_value.data ();
+    b[n].size = &i.release_size;
+    b[n].capacity = i.release_value.capacity ();
+    b[n].is_null = &i.release_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::_version, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // epoch
+    //
+    {
+      ::uint16_t const& v =
+        o.epoch;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::uint16_t,
+          sqlite::id_integer >::set_image (
+        i.epoch_value,
+        is_null,
+        v);
+      i.epoch_null = is_null;
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string const& v =
+        o.canonical_upstream;
+
+      bool is_null (false);
+      std::size_t cap (i.canonical_upstream_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.canonical_upstream_value,
+        i.canonical_upstream_size,
+        is_null,
+        v);
+      i.canonical_upstream_null = is_null;
+      grew = grew || (cap != i.canonical_upstream_value.capacity ());
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string const& v =
+        o.canonical_release;
+
+      bool is_null (false);
+      std::size_t cap (i.canonical_release_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.canonical_release_value,
+        i.canonical_release_size,
+        is_null,
+        v);
+      i.canonical_release_null = is_null;
+      grew = grew || (cap != i.canonical_release_value.capacity ());
+    }
+
+    // revision
+    //
+    {
+      ::butl::optional< short unsigned int > const& v =
+        o.revision;
+
+      bool is_null (true);
+      sqlite::value_traits<
+          ::butl::optional< short unsigned int >,
+          sqlite::id_integer >::set_image (
+        i.revision_value,
+        is_null,
+        v);
+      i.revision_null = is_null;
+    }
+
+    // iteration
+    //
+    {
+      ::uint32_t const& v =
+        o.iteration;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::uint32_t,
+          sqlite::id_integer >::set_image (
+        i.iteration_value,
+        is_null,
+        v);
+      i.iteration_null = is_null;
+    }
+
+    // upstream
+    //
+    {
+      ::std::string const& v =
+        o.upstream;
+
+      bool is_null (false);
+      std::size_t cap (i.upstream_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.upstream_value,
+        i.upstream_size,
+        is_null,
+        v);
+      i.upstream_null = is_null;
+      grew = grew || (cap != i.upstream_value.capacity ());
+    }
+
+    // release
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.release;
+
+      bool is_null (true);
+      std::size_t cap (i.release_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.release_value,
+        i.release_size,
+        is_null,
+        v);
+      i.release_null = is_null;
+      grew = grew || (cap != i.release_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::_version, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // epoch
+    //
+    {
+      ::uint16_t& v =
+        o.epoch;
+
+      sqlite::value_traits<
+          ::uint16_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.epoch_value,
+        i.epoch_null);
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string& v =
+        o.canonical_upstream;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.canonical_upstream_value,
+        i.canonical_upstream_size,
+        i.canonical_upstream_null);
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string& v =
+        o.canonical_release;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.canonical_release_value,
+        i.canonical_release_size,
+        i.canonical_release_null);
+    }
+
+    // revision
+    //
+    {
+      ::butl::optional< short unsigned int >& v =
+        o.revision;
+
+      sqlite::value_traits<
+          ::butl::optional< short unsigned int >,
+          sqlite::id_integer >::set_value (
+        v,
+        i.revision_value,
+        i.revision_null);
+    }
+
+    // iteration
+    //
+    {
+      ::uint32_t& v =
+        o.iteration;
+
+      sqlite::value_traits<
+          ::uint32_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.iteration_value,
+        i.iteration_null);
+    }
+
+    // upstream
+    //
+    {
+      ::std::string& v =
+        o.upstream;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.upstream_value,
+        i.upstream_size,
+        i.upstream_null);
+    }
+
+    // release
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.release;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.release_value,
+        i.release_size,
+        i.release_null);
+    }
+  }
+
+  // language
+  //
+
+  bool access::composite_value_traits< ::bpkg::language, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // impl
+    //
+    t[1UL] = false;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::language, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // impl
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.impl_value;
+    b[n].is_null = &i.impl_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::language, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    {
+      ::std::string const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // impl
+    //
+    {
+      bool const& v =
+        o.impl;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.impl_value,
+        is_null,
+        v);
+      i.impl_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::language, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // impl
+    //
+    {
+      bool& v =
+        o.impl;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.impl_value,
+        i.impl_null);
+    }
+  }
+
+  // version_constraint
+  //
+
+  bool access::composite_value_traits< ::bpkg::version_constraint, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // min_version
+    //
+    if (composite_value_traits< ::bpkg::_version, id_sqlite >::grow (
+          i.min_version_value, t + 0UL))
+      grew = true;
+
+    // max_version
+    //
+    if (composite_value_traits< ::bpkg::_version, id_sqlite >::grow (
+          i.max_version_value, t + 7UL))
+      grew = true;
+
+    // min_open
+    //
+    t[14UL] = false;
+
+    // max_open
+    //
+    t[15UL] = false;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::version_constraint, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // min_version
+    //
+    composite_value_traits< ::bpkg::_version, id_sqlite >::bind (
+      b + n, i.min_version_value, sk);
+    n += 7UL;
+
+    // max_version
+    //
+    composite_value_traits< ::bpkg::_version, id_sqlite >::bind (
+      b + n, i.max_version_value, sk);
+    n += 7UL;
+
+    // min_open
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.min_open_value;
+    b[n].is_null = &i.min_open_null;
+    n++;
+
+    // max_open
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.max_open_value;
+    b[n].is_null = &i.max_open_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::version_constraint, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // min_version
+    //
+    {
+      ::butl::optional< ::bpkg::version > const& v =
+        o.min_version;
+
+      // From package.hxx:325:14
+      ::bpkg::_optional_version const& vt =
+        (v) ? bpkg::_version 
+      {
+         (v)->epoch, (v)->canonical_upstream, (v)->canonical_release, (v)->revision, (v)->iteration, (v)->upstream, (v)->release 
+      } : bpkg::_optional_version ();
+
+      if (wrapper_traits< ::bpkg::_optional_version >::get_null (vt))
+        composite_value_traits< ::bpkg::_version, id_sqlite >::set_null (
+          i.min_version_value, sk);
+      else
+      {
+        const::bpkg::_version& vw = 
+          wrapper_traits< ::bpkg::_optional_version >::get_ref (vt);
+
+        if (composite_value_traits< ::bpkg::_version, id_sqlite >::init (
+              i.min_version_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // max_version
+    //
+    {
+      ::butl::optional< ::bpkg::version > const& v =
+        o.max_version;
+
+      // From package.hxx:325:14
+      ::bpkg::_optional_version const& vt =
+        (v) ? bpkg::_version 
+      {
+         (v)->epoch, (v)->canonical_upstream, (v)->canonical_release, (v)->revision, (v)->iteration, (v)->upstream, (v)->release 
+      } : bpkg::_optional_version ();
+
+      if (wrapper_traits< ::bpkg::_optional_version >::get_null (vt))
+        composite_value_traits< ::bpkg::_version, id_sqlite >::set_null (
+          i.max_version_value, sk);
+      else
+      {
+        const::bpkg::_version& vw = 
+          wrapper_traits< ::bpkg::_optional_version >::get_ref (vt);
+
+        if (composite_value_traits< ::bpkg::_version, id_sqlite >::init (
+              i.max_version_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    // min_open
+    //
+    {
+      bool const& v =
+        o.min_open;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.min_open_value,
+        is_null,
+        v);
+      i.min_open_null = is_null;
+    }
+
+    // max_open
+    //
+    {
+      bool const& v =
+        o.max_open;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.max_open_value,
+        is_null,
+        v);
+      i.max_open_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::version_constraint, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // min_version
+    //
+    {
+      ::butl::optional< ::bpkg::version >& v =
+        o.min_version;
+
+      ::bpkg::_optional_version vt;
+
+      if (composite_value_traits< ::bpkg::_version, id_sqlite >::get_null (
+            i.min_version_value))
+        wrapper_traits< ::bpkg::_optional_version >::set_null (vt);
+      else
+      {
+        ::bpkg::_version& vw =
+          wrapper_traits< ::bpkg::_optional_version >::set_ref (vt);
+
+        composite_value_traits< ::bpkg::_version, id_sqlite >::init (
+          vw,
+          i.min_version_value,
+          db);
+      }
+
+      // From package.hxx:325:14
+      v = (vt) ? bpkg::version ((vt)->epoch, std::move ((vt)->upstream), std::move ((vt)->release), (vt)->revision, (vt)->iteration) : bpkg::optional_version ();
+    }
+
+    // max_version
+    //
+    {
+      ::butl::optional< ::bpkg::version >& v =
+        o.max_version;
+
+      ::bpkg::_optional_version vt;
+
+      if (composite_value_traits< ::bpkg::_version, id_sqlite >::get_null (
+            i.max_version_value))
+        wrapper_traits< ::bpkg::_optional_version >::set_null (vt);
+      else
+      {
+        ::bpkg::_version& vw =
+          wrapper_traits< ::bpkg::_optional_version >::set_ref (vt);
+
+        composite_value_traits< ::bpkg::_version, id_sqlite >::init (
+          vw,
+          i.max_version_value,
+          db);
+      }
+
+      // From package.hxx:325:14
+      v = (vt) ? bpkg::version ((vt)->epoch, std::move ((vt)->upstream), std::move ((vt)->release), (vt)->revision, (vt)->iteration) : bpkg::optional_version ();
+    }
+
+    // min_open
+    //
+    {
+      bool& v =
+        o.min_open;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.min_open_value,
+        i.min_open_null);
+    }
+
+    // max_open
+    //
+    {
+      bool& v =
+        o.max_open;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.max_open_value,
+        i.max_open_null);
+    }
+  }
+
+  // dependency
+  //
+
+  bool access::composite_value_traits< ::bpkg::dependency, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // constraint
+    //
+    if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::grow (
+          i.constraint_value, t + 1UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::package_name,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // constraint
+    //
+    composite_value_traits< ::bpkg::version_constraint, id_sqlite >::bind (
+      b + n, i.constraint_value, sk);
+    n += 16UL;
+  }
+
+  bool access::composite_value_traits< ::bpkg::dependency, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    {
+      ::bpkg::package_name const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // constraint
+    //
+    {
+      ::butl::optional< ::bpkg::version_constraint > const& v =
+        o.constraint;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_null (v))
+        composite_value_traits< ::bpkg::version_constraint, id_sqlite >::set_null (
+          i.constraint_value, sk);
+      else
+      {
+        const::bpkg::version_constraint& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::init (
+              i.constraint_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::bpkg::package_name& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // constraint
+    //
+    {
+      ::butl::optional< ::bpkg::version_constraint >& v =
+        o.constraint;
+
+      if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::get_null (
+            i.constraint_value))
+        wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_null (v);
+      else
+      {
+        ::bpkg::version_constraint& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::version_constraint, id_sqlite >::init (
+          vw,
+          i.constraint_value,
+          db);
+      }
+    }
+  }
+
+  // dependency_alternative
+  //
+
+  bool access::composite_value_traits< ::bpkg::dependency_alternative, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // enable
+    //
+    if (t[0UL])
+    {
+      i.enable_value.capacity (i.enable_size);
+      grew = true;
+    }
+
+    // reflect
+    //
+    if (t[1UL])
+    {
+      i.reflect_value.capacity (i.reflect_size);
+      grew = true;
+    }
+
+    // prefer
+    //
+    if (t[2UL])
+    {
+      i.prefer_value.capacity (i.prefer_size);
+      grew = true;
+    }
+
+    // accept
+    //
+    if (t[3UL])
+    {
+      i.accept_value.capacity (i.accept_size);
+      grew = true;
+    }
+
+    // require
+    //
+    if (t[4UL])
+    {
+      i.require_value.capacity (i.require_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency_alternative, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // enable
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.enable_value.data ();
+    b[n].size = &i.enable_size;
+    b[n].capacity = i.enable_value.capacity ();
+    b[n].is_null = &i.enable_null;
+    n++;
+
+    // reflect
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.reflect_value.data ();
+    b[n].size = &i.reflect_size;
+    b[n].capacity = i.reflect_value.capacity ();
+    b[n].is_null = &i.reflect_null;
+    n++;
+
+    // prefer
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.prefer_value.data ();
+    b[n].size = &i.prefer_size;
+    b[n].capacity = i.prefer_value.capacity ();
+    b[n].is_null = &i.prefer_null;
+    n++;
+
+    // accept
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.accept_value.data ();
+    b[n].size = &i.accept_size;
+    b[n].capacity = i.accept_value.capacity ();
+    b[n].is_null = &i.accept_null;
+    n++;
+
+    // require
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.require_value.data ();
+    b[n].size = &i.require_size;
+    b[n].capacity = i.require_value.capacity ();
+    b[n].is_null = &i.require_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::dependency_alternative, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // enable
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.enable;
+
+      bool is_null (true);
+      std::size_t cap (i.enable_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.enable_value,
+        i.enable_size,
+        is_null,
+        v);
+      i.enable_null = is_null;
+      grew = grew || (cap != i.enable_value.capacity ());
+    }
+
+    // reflect
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.reflect;
+
+      bool is_null (true);
+      std::size_t cap (i.reflect_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.reflect_value,
+        i.reflect_size,
+        is_null,
+        v);
+      i.reflect_null = is_null;
+      grew = grew || (cap != i.reflect_value.capacity ());
+    }
+
+    // prefer
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.prefer;
+
+      bool is_null (true);
+      std::size_t cap (i.prefer_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.prefer_value,
+        i.prefer_size,
+        is_null,
+        v);
+      i.prefer_null = is_null;
+      grew = grew || (cap != i.prefer_value.capacity ());
+    }
+
+    // accept
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.accept;
+
+      bool is_null (true);
+      std::size_t cap (i.accept_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.accept_value,
+        i.accept_size,
+        is_null,
+        v);
+      i.accept_null = is_null;
+      grew = grew || (cap != i.accept_value.capacity ());
+    }
+
+    // require
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.require;
+
+      bool is_null (true);
+      std::size_t cap (i.require_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.require_value,
+        i.require_size,
+        is_null,
+        v);
+      i.require_null = is_null;
+      grew = grew || (cap != i.require_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency_alternative, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // enable
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.enable;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.enable_value,
+        i.enable_size,
+        i.enable_null);
+    }
+
+    // reflect
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.reflect;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.reflect_value,
+        i.reflect_size,
+        i.reflect_null);
+    }
+
+    // prefer
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.prefer;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.prefer_value,
+        i.prefer_size,
+        i.prefer_null);
+    }
+
+    // accept
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.accept;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.accept_value,
+        i.accept_size,
+        i.accept_null);
+    }
+
+    // require
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.require;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.require_value,
+        i.require_size,
+        i.require_null);
+    }
+  }
+
+  // dependency_alternatives
+  //
+
+  bool access::composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // buildtime
+    //
+    t[0UL] = false;
+
+    // comment
+    //
+    if (t[1UL])
+    {
+      i.comment_value.capacity (i.comment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // buildtime
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.buildtime_value;
+    b[n].is_null = &i.buildtime_null;
+    n++;
+
+    // comment
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.comment_value.data ();
+    b[n].size = &i.comment_size;
+    b[n].capacity = i.comment_value.capacity ();
+    b[n].is_null = &i.comment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // buildtime
+    //
+    {
+      bool const& v =
+        o.buildtime;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.buildtime_value,
+        is_null,
+        v);
+      i.buildtime_null = is_null;
+    }
+
+    // comment
+    //
+    {
+      ::std::string const& v =
+        o.comment;
+
+      bool is_null (false);
+      std::size_t cap (i.comment_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.comment_value,
+        i.comment_size,
+        is_null,
+        v);
+      i.comment_null = is_null;
+      grew = grew || (cap != i.comment_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // buildtime
+    //
+    {
+      bool& v =
+        o.buildtime;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.buildtime_value,
+        i.buildtime_null);
+    }
+
+    // comment
+    //
+    {
+      ::std::string& v =
+        o.comment;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.comment_value,
+        i.comment_size,
+        i.comment_null);
+    }
+  }
+
+  // test_dependency
+  //
+
+  bool access::composite_value_traits< ::bpkg::test_dependency, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // dependency base
+    //
+    if (composite_value_traits< ::bpkg::dependency, id_sqlite >::grow (
+          i, t + 0UL))
+      grew = true;
+
+    // type
+    //
+    if (t[17UL])
+    {
+      i.type_value.capacity (i.type_size);
+      grew = true;
+    }
+
+    // buildtime
+    //
+    t[18UL] = false;
+
+    // enable
+    //
+    if (t[19UL])
+    {
+      i.enable_value.capacity (i.enable_size);
+      grew = true;
+    }
+
+    // reflect
+    //
+    if (t[20UL])
+    {
+      i.reflect_value.capacity (i.reflect_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::test_dependency, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // dependency base
+    //
+    composite_value_traits< ::bpkg::dependency, id_sqlite >::bind (b + n, i, sk);
+    n += 17UL;
+
+    // type
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.type_value.data ();
+    b[n].size = &i.type_size;
+    b[n].capacity = i.type_value.capacity ();
+    b[n].is_null = &i.type_null;
+    n++;
+
+    // buildtime
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.buildtime_value;
+    b[n].is_null = &i.buildtime_null;
+    n++;
+
+    // enable
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.enable_value.data ();
+    b[n].size = &i.enable_size;
+    b[n].capacity = i.enable_value.capacity ();
+    b[n].is_null = &i.enable_null;
+    n++;
+
+    // reflect
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.reflect_value.data ();
+    b[n].size = &i.reflect_size;
+    b[n].capacity = i.reflect_value.capacity ();
+    b[n].is_null = &i.reflect_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::test_dependency, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // dependency base
+    //
+    if (composite_value_traits< ::bpkg::dependency, id_sqlite >::init (i, o, sk))
+      grew = true;
+
+    // type
+    //
+    {
+      ::bpkg::test_dependency_type const& v =
+        o.type;
+
+      // From package.hxx:629:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t cap (i.type_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.type_value,
+        i.type_size,
+        is_null,
+        vt);
+      i.type_null = is_null;
+      grew = grew || (cap != i.type_value.capacity ());
+    }
+
+    // buildtime
+    //
+    {
+      bool const& v =
+        o.buildtime;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.buildtime_value,
+        is_null,
+        v);
+      i.buildtime_null = is_null;
+    }
+
+    // enable
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.enable;
+
+      bool is_null (true);
+      std::size_t cap (i.enable_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.enable_value,
+        i.enable_size,
+        is_null,
+        v);
+      i.enable_null = is_null;
+      grew = grew || (cap != i.enable_value.capacity ());
+    }
+
+    // reflect
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.reflect;
+
+      bool is_null (true);
+      std::size_t cap (i.reflect_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.reflect_value,
+        i.reflect_size,
+        is_null,
+        v);
+      i.reflect_null = is_null;
+      grew = grew || (cap != i.reflect_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::test_dependency, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // dependency base
+    //
+    composite_value_traits< ::bpkg::dependency, id_sqlite >::init (o, i, db);
+
+    // type
+    //
+    {
+      ::bpkg::test_dependency_type& v =
+        o.type;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.type_value,
+        i.type_size,
+        i.type_null);
+
+      // From package.hxx:629:14
+      v = bpkg::to_test_dependency_type (vt);
+    }
+
+    // buildtime
+    //
+    {
+      bool& v =
+        o.buildtime;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.buildtime_value,
+        i.buildtime_null);
+    }
+
+    // enable
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.enable;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.enable_value,
+        i.enable_size,
+        i.enable_null);
+    }
+
+    // reflect
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.reflect;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.reflect_value,
+        i.reflect_size,
+        i.reflect_null);
+    }
+  }
+
+  // buildfile
+  //
+
+  bool access::composite_value_traits< ::bpkg::buildfile, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // path
+    //
+    if (t[0UL])
+    {
+      i.path_value.capacity (i.path_size);
+      grew = true;
+    }
+
+    // content
+    //
+    if (t[1UL])
+    {
+      i.content_value.capacity (i.content_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::buildfile, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // path
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.path_value.data ();
+    b[n].size = &i.path_size;
+    b[n].capacity = i.path_value.capacity ();
+    b[n].is_null = &i.path_null;
+    n++;
+
+    // content
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.content_value.data ();
+    b[n].size = &i.content_size;
+    b[n].capacity = i.content_value.capacity ();
+    b[n].is_null = &i.content_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::buildfile, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // path
+    //
+    {
+      ::butl::path const& v =
+        o.path;
+
+      // From package.hxx:50:14
+      ::std::string const& vt =
+        (v).representation ();
+
+      bool is_null (false);
+      std::size_t cap (i.path_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.path_value,
+        i.path_size,
+        is_null,
+        vt);
+      i.path_null = is_null;
+      grew = grew || (cap != i.path_value.capacity ());
+    }
+
+    // content
+    //
+    {
+      ::std::string const& v =
+        o.content;
+
+      bool is_null (false);
+      std::size_t cap (i.content_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.content_value,
+        i.content_size,
+        is_null,
+        v);
+      i.content_null = is_null;
+      grew = grew || (cap != i.content_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::buildfile, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // path
+    //
+    {
+      ::butl::path& v =
+        o.path;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.path_value,
+        i.path_size,
+        i.path_null);
+
+      // From package.hxx:50:14
+      v = bpkg::path (vt);
+    }
+
+    // content
+    //
+    {
+      ::std::string& v =
+        o.content;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.content_value,
+        i.content_size,
+        i.content_null);
+    }
+  }
+
+  // distribution_name_value
+  //
+
+  bool access::composite_value_traits< ::bpkg::distribution_name_value, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // value
+    //
+    if (t[1UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::distribution_name_value, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // value
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.value_value.data ();
+    b[n].size = &i.value_size;
+    b[n].capacity = i.value_value.capacity ();
+    b[n].is_null = &i.value_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::distribution_name_value, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    {
+      ::std::string const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // value
+    //
+    {
+      ::std::string const& v =
+        o.value;
+
+      bool is_null (false);
+      std::size_t cap (i.value_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.value_value,
+        i.value_size,
+        is_null,
+        v);
+      i.value_null = is_null;
+      grew = grew || (cap != i.value_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::distribution_name_value, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // value
+    //
+    {
+      ::std::string& v =
+        o.value;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.value_value,
+        i.value_size,
+        i.value_null);
+    }
+  }
+
+  // configuration
+  //
+
+  struct access::object_traits_impl< ::bpkg::configuration, id_sqlite >::extra_statement_cache_type
+  {
+    extra_statement_cache_type (
+      sqlite::connection&,
+      image_type&,
+      id_image_type&,
+      sqlite::binding&,
+      sqlite::binding&)
+    {
+    }
+  };
+
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::id_type
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  id (const id_image_type& i)
+  {
+    sqlite::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      sqlite::value_traits<
+          ::bpkg::optional_uint64_t,
+          sqlite::id_integer >::set_value (
+        id,
+        i.id_value,
+        i.id_null);
+    }
+
+    return id;
+  }
+
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::id_type
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  id (const image_type& i)
+  {
+    sqlite::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      sqlite::value_traits<
+          ::bpkg::optional_uint64_t,
+          sqlite::id_integer >::set_value (
+        id,
+        i.id_value,
+        i.id_null);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    t[0UL] = false;
+
+    // uuid
+    //
+    if (t[1UL])
+    {
+      i.uuid_value.capacity (i.uuid_size);
+      grew = true;
+    }
+
+    // name
+    //
+    if (t[2UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // type
+    //
+    if (t[3UL])
+    {
+      i.type_value.capacity (i.type_size);
+      grew = true;
+    }
+
+    // path
+    //
+    if (t[4UL])
+    {
+      i.path_value.capacity (i.path_size);
+      grew = true;
+    }
+
+    // expl
+    //
+    t[5UL] = false;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      b[n].type = sqlite::bind::integer;
+      b[n].buffer = &i.id_value;
+      b[n].is_null = &i.id_null;
+      n++;
+    }
+
+    // uuid
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.uuid_value.data ();
+    b[n].size = &i.uuid_size;
+    b[n].capacity = i.uuid_value.capacity ();
+    b[n].is_null = &i.uuid_null;
+    n++;
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // type
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.type_value.data ();
+    b[n].size = &i.type_size;
+    b[n].capacity = i.type_value.capacity ();
+    b[n].is_null = &i.type_null;
+    n++;
+
+    // path
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.path_value.data ();
+    b[n].size = &i.path_size;
+    b[n].capacity = i.path_value.capacity ();
+    b[n].is_null = &i.path_null;
+    n++;
+
+    // expl
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.expl_value;
+    b[n].is_null = &i.expl_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  bind (sqlite::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.id_value;
+    b[n].is_null = &i.id_null;
+  }
+
+  bool access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  init (image_type& i,
+        const object_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::bpkg::optional_uint64_t const& v =
+        o.id;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::bpkg::optional_uint64_t,
+          sqlite::id_integer >::set_image (
+        i.id_value,
+        is_null,
+        v);
+      i.id_null = is_null;
+    }
+
+    // uuid
+    //
+    {
+      ::bpkg::configuration::uuid_type const& v =
+        o.uuid;
+
+      // From package.hxx:66:14
+      ::std::string const& vt =
+        (v).string ();
+
+      bool is_null (false);
+      std::size_t cap (i.uuid_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.uuid_value,
+        i.uuid_size,
+        is_null,
+        vt);
+      i.uuid_null = is_null;
+      grew = grew || (cap != i.uuid_value.capacity ());
+    }
+
+    // name
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.name;
+
+      bool is_null (true);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // type
+    //
+    {
+      ::std::string const& v =
+        o.type;
+
+      bool is_null (false);
+      std::size_t cap (i.type_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.type_value,
+        i.type_size,
+        is_null,
+        v);
+      i.type_null = is_null;
+      grew = grew || (cap != i.type_value.capacity ());
+    }
+
+    // path
+    //
+    {
+      ::butl::dir_path const& v =
+        o.path;
+
+      // From package.hxx:57:14
+      ::std::string const& vt =
+        (v).string ();
+
+      bool is_null (false);
+      std::size_t cap (i.path_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.path_value,
+        i.path_size,
+        is_null,
+        vt);
+      i.path_null = is_null;
+      grew = grew || (cap != i.path_value.capacity ());
+    }
+
+    // expl
+    //
+    {
+      bool const& v =
+        o.expl;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.expl_value,
+        is_null,
+        v);
+      i.expl_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::bpkg::optional_uint64_t& v =
+        o.id;
+
+      sqlite::value_traits<
+          ::bpkg::optional_uint64_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.id_value,
+        i.id_null);
+    }
+
+    // uuid
+    //
+    {
+      ::bpkg::configuration::uuid_type& v =
+        o.uuid;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.uuid_value,
+        i.uuid_size,
+        i.uuid_null);
+
+      // From package.hxx:66:14
+      v = bpkg::uuid (vt);
+    }
+
+    // name
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // type
+    //
+    {
+      ::std::string& v =
+        o.type;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.type_value,
+        i.type_size,
+        i.type_null);
+    }
+
+    // path
+    //
+    {
+      ::butl::dir_path& v =
+        o.path;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.path_value,
+        i.path_size,
+        i.path_null);
+
+      // From package.hxx:57:14
+      v = bpkg::dir_path (vt);
+    }
+
+    // expl
+    //
+    {
+      bool& v =
+        o.expl;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.expl_value,
+        i.expl_null);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  init (id_image_type& i, const id_type& id)
+  {
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          ::bpkg::optional_uint64_t,
+          sqlite::id_integer >::set_image (
+        i.id_value,
+        is_null,
+        id);
+      i.id_null = is_null;
+    }
+  }
+
+  const char access::object_traits_impl< ::bpkg::configuration, id_sqlite >::persist_statement[] =
+  "INSERT INTO \"main\".\"configuration\" "
+  "(\"id\", "
+  "\"uuid\", "
+  "\"name\", "
+  "\"type\", "
+  "\"path\", "
+  "\"explicit\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::configuration, id_sqlite >::find_statement[] =
+  "SELECT "
+  "\"main\".\"configuration\".\"id\", "
+  "\"main\".\"configuration\".\"uuid\", "
+  "\"main\".\"configuration\".\"name\", "
+  "\"main\".\"configuration\".\"type\", "
+  "\"main\".\"configuration\".\"path\", "
+  "\"main\".\"configuration\".\"explicit\" "
+  "FROM \"main\".\"configuration\" "
+  "WHERE \"main\".\"configuration\".\"id\"=?";
+
+  const char access::object_traits_impl< ::bpkg::configuration, id_sqlite >::update_statement[] =
+  "UPDATE \"main\".\"configuration\" "
+  "SET "
+  "\"uuid\"=?, "
+  "\"name\"=?, "
+  "\"type\"=?, "
+  "\"path\"=?, "
+  "\"explicit\"=? "
+  "WHERE \"id\"=?";
+
+  const char access::object_traits_impl< ::bpkg::configuration, id_sqlite >::erase_statement[] =
+  "DELETE FROM \"main\".\"configuration\" "
+  "WHERE \"id\"=?";
+
+  const char access::object_traits_impl< ::bpkg::configuration, id_sqlite >::query_statement[] =
+  "SELECT "
+  "\"main\".\"configuration\".\"id\", "
+  "\"main\".\"configuration\".\"uuid\", "
+  "\"main\".\"configuration\".\"name\", "
+  "\"main\".\"configuration\".\"type\", "
+  "\"main\".\"configuration\".\"path\", "
+  "\"main\".\"configuration\".\"explicit\" "
+  "FROM \"main\".\"configuration\"";
+
+  const char access::object_traits_impl< ::bpkg::configuration, id_sqlite >::erase_query_statement[] =
+  "DELETE FROM \"main\".\"configuration\"";
+
+  const char access::object_traits_impl< ::bpkg::configuration, id_sqlite >::table_name[] =
+  "\"main\".\"configuration\"";
+
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  persist (database& db, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              static_cast<const object_type&> (obj),
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    {
+      id_image_type& i (sts.id_image ());
+      binding& b (sts.id_image_binding ());
+      if (i.version != sts.id_image_version () || b.version == 0)
+      {
+        bind (b.bind, i);
+        sts.id_image_version (i.version);
+        b.version++;
+      }
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    obj.id = id (sts.id_image ());
+
+    callback (db,
+              static_cast<const object_type&> (obj),
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace sqlite;
+    using sqlite::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    sqlite::connection& conn (tr.connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::pointer_type
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  find (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace sqlite;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  result< access::object_traits_impl< ::bpkg::configuration, id_sqlite >::object_type >
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) sqlite::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  erase_query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      text,
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // canonical_version
+  //
+
+  bool access::composite_value_traits< ::bpkg::canonical_version, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // epoch
+    //
+    t[0UL] = false;
+
+    // canonical_upstream
+    //
+    if (t[1UL])
+    {
+      i.canonical_upstream_value.capacity (i.canonical_upstream_size);
+      grew = true;
+    }
+
+    // canonical_release
+    //
+    if (t[2UL])
+    {
+      i.canonical_release_value.capacity (i.canonical_release_size);
+      grew = true;
+    }
+
+    // revision
+    //
+    t[3UL] = false;
+
+    // iteration
+    //
+    t[4UL] = false;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::canonical_version, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // epoch
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.epoch_value;
+    b[n].is_null = &i.epoch_null;
+    n++;
+
+    // canonical_upstream
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.canonical_upstream_value.data ();
+    b[n].size = &i.canonical_upstream_size;
+    b[n].capacity = i.canonical_upstream_value.capacity ();
+    b[n].is_null = &i.canonical_upstream_null;
+    n++;
+
+    // canonical_release
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.canonical_release_value.data ();
+    b[n].size = &i.canonical_release_size;
+    b[n].capacity = i.canonical_release_value.capacity ();
+    b[n].is_null = &i.canonical_release_null;
+    n++;
+
+    // revision
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.revision_value;
+    b[n].is_null = &i.revision_null;
+    n++;
+
+    // iteration
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.iteration_value;
+    b[n].is_null = &i.iteration_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::canonical_version, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // epoch
+    //
+    {
+      ::uint16_t const& v =
+        o.epoch;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::uint16_t,
+          sqlite::id_integer >::set_image (
+        i.epoch_value,
+        is_null,
+        v);
+      i.epoch_null = is_null;
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string const& v =
+        o.canonical_upstream;
+
+      bool is_null (false);
+      std::size_t cap (i.canonical_upstream_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.canonical_upstream_value,
+        i.canonical_upstream_size,
+        is_null,
+        v);
+      i.canonical_upstream_null = is_null;
+      grew = grew || (cap != i.canonical_upstream_value.capacity ());
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string const& v =
+        o.canonical_release;
+
+      bool is_null (false);
+      std::size_t cap (i.canonical_release_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.canonical_release_value,
+        i.canonical_release_size,
+        is_null,
+        v);
+      i.canonical_release_null = is_null;
+      grew = grew || (cap != i.canonical_release_value.capacity ());
+    }
+
+    // revision
+    //
+    {
+      ::uint16_t const& v =
+        o.revision;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::uint16_t,
+          sqlite::id_integer >::set_image (
+        i.revision_value,
+        is_null,
+        v);
+      i.revision_null = is_null;
+    }
+
+    // iteration
+    //
+    {
+      ::uint32_t const& v =
+        o.iteration;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::uint32_t,
+          sqlite::id_integer >::set_image (
+        i.iteration_value,
+        is_null,
+        v);
+      i.iteration_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::canonical_version, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // epoch
+    //
+    {
+      ::uint16_t& v =
+        o.epoch;
+
+      sqlite::value_traits<
+          ::uint16_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.epoch_value,
+        i.epoch_null);
+    }
+
+    // canonical_upstream
+    //
+    {
+      ::std::string& v =
+        o.canonical_upstream;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.canonical_upstream_value,
+        i.canonical_upstream_size,
+        i.canonical_upstream_null);
+    }
+
+    // canonical_release
+    //
+    {
+      ::std::string& v =
+        o.canonical_release;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.canonical_release_value,
+        i.canonical_release_size,
+        i.canonical_release_null);
+    }
+
+    // revision
+    //
+    {
+      ::uint16_t& v =
+        o.revision;
+
+      sqlite::value_traits<
+          ::uint16_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.revision_value,
+        i.revision_null);
+    }
+
+    // iteration
+    //
+    {
+      ::uint32_t& v =
+        o.iteration;
+
+      sqlite::value_traits<
+          ::uint32_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.iteration_value,
+        i.iteration_null);
+    }
+  }
+
+  // upstream_version
+  //
+
+  bool access::composite_value_traits< ::bpkg::upstream_version, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // upstream_
+    //
+    if (t[0UL])
+    {
+      i.upstream_value.capacity (i.upstream_size);
+      grew = true;
+    }
+
+    // release_
+    //
+    if (t[1UL])
+    {
+      i.release_value.capacity (i.release_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::upstream_version, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // upstream_
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.upstream_value.data ();
+    b[n].size = &i.upstream_size;
+    b[n].capacity = i.upstream_value.capacity ();
+    b[n].is_null = &i.upstream_null;
+    n++;
+
+    // release_
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::optional_string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.release_value.data ();
+    b[n].size = &i.release_size;
+    b[n].capacity = i.release_value.capacity ();
+    b[n].is_null = &i.release_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::upstream_version, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // upstream_
+    //
+    {
+      // From package.hxx:276:7
+      ::std::string const& v =
+        o.upstream;
+
+      bool is_null (false);
+      std::size_t cap (i.upstream_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.upstream_value,
+        i.upstream_size,
+        is_null,
+        v);
+      i.upstream_null = is_null;
+      grew = grew || (cap != i.upstream_value.capacity ());
+    }
+
+    // release_
+    //
+    {
+      // From package.hxx:281:7
+      ::bpkg::optional_string const& v =
+        o.release;
+
+      bool is_null (true);
+      std::size_t cap (i.release_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_image (
+        i.release_value,
+        i.release_size,
+        is_null,
+        v);
+      i.release_null = is_null;
+      grew = grew || (cap != i.release_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::upstream_version, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // upstream_
+    //
+    {
+      // From package.hxx:277:7
+      ::std::string v;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.upstream_value,
+        i.upstream_size,
+        i.upstream_null);
+
+      // From package.hxx:277:7
+      o = bpkg::version (0, std::move (v), std::string (), bpkg::nullopt, 0);
+    }
+
+    // release_
+    //
+    {
+      // From package.hxx:282:7
+      ::bpkg::optional_string v;
+
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_value (
+        v,
+        i.release_value,
+        i.release_size,
+        i.release_null);
+
+      // From package.hxx:282:7
+      o = bpkg::version (0, std::move (o.upstream), std::move (v), bpkg::nullopt, 0);
+    }
+  }
+
+  // _repository_location
+  //
+
+  bool access::composite_value_traits< ::bpkg::_repository_location, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // url
+    //
+    if (t[0UL])
+    {
+      i.url_value.capacity (i.url_size);
+      grew = true;
+    }
+
+    // type
+    //
+    if (t[1UL])
+    {
+      i.type_value.capacity (i.type_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::_repository_location, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // url
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.url_value.data ();
+    b[n].size = &i.url_size;
+    b[n].capacity = i.url_value.capacity ();
+    b[n].is_null = &i.url_null;
+    n++;
+
+    // type
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.type_value.data ();
+    b[n].size = &i.type_size;
+    b[n].capacity = i.type_value.capacity ();
+    b[n].is_null = &i.type_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::_repository_location, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // url
+    //
+    {
+      ::bpkg::repository_url const& v =
+        o.url;
+
+      // From package.hxx:358:14
+      ::std::string const& vt =
+        (v).string ();
+
+      bool is_null (false);
+      std::size_t cap (i.url_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.url_value,
+        i.url_size,
+        is_null,
+        vt);
+      i.url_null = is_null;
+      grew = grew || (cap != i.url_value.capacity ());
+    }
+
+    // type
+    //
+    {
+      ::bpkg::repository_type const& v =
+        o.type;
+
+      // From package.hxx:362:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t cap (i.type_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.type_value,
+        i.type_size,
+        is_null,
+        vt);
+      i.type_null = is_null;
+      grew = grew || (cap != i.type_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::_repository_location, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // url
+    //
+    {
+      ::bpkg::repository_url& v =
+        o.url;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.url_value,
+        i.url_size,
+        i.url_null);
+
+      // From package.hxx:358:14
+      v = (vt).empty () ? bpkg::repository_url () : bpkg::repository_url (vt);
+    }
+
+    // type
+    //
+    {
+      ::bpkg::repository_type& v =
+        o.type;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.type_value,
+        i.type_size,
+        i.type_null);
+
+      // From package.hxx:362:14
+      v = bpkg::to_repository_type (vt);
+    }
+  }
+
+  // repository_fragment
+  //
+
+  struct access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::extra_statement_cache_type
+  {
+    sqlite::container_statements_impl< complements_traits > complements;
+    sqlite::container_statements_impl< prerequisites_traits > prerequisites;
+
+    extra_statement_cache_type (
+      sqlite::connection& c,
+      image_type&,
+      id_image_type&,
+      sqlite::binding& id,
+      sqlite::binding&)
+    : complements (c, id),
+      prerequisites (c, id)
+    {
+    }
+  };
+
+  // complements
+  //
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"repository_fragment_complements\".\"complement\" "
+  "FROM \"main\".\"repository_fragment_complements\" "
+  "WHERE \"main\".\"repository_fragment_complements\".\"repository_fragment\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"repository_fragment_complements\" "
+  "(\"repository_fragment\", "
+  "\"complement\") "
+  "VALUES "
+  "(?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"repository_fragment_complements\" "
+  "WHERE \"repository_fragment\"=?";
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // value
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = d.value_value.data ();
+    b[n].size = &d.value_size;
+    b[n].capacity = d.value_value.capacity ();
+    b[n].is_null = &d.value_null;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // value
+    //
+    if (t[0UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  init (data_image_type& i,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // value
+    //
+    {
+      typedef object_traits< ::bpkg::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > wptr_traits;
+      typedef odb::pointer_traits< wptr_traits::strong_pointer_type > ptr_traits;
+
+      wptr_traits::strong_pointer_type sp (wptr_traits::lock (v));
+      bool is_null (ptr_traits::null_ptr (sp));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (sp));
+
+        std::size_t cap (i.value_value.capacity ());
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_image (
+          i.value_value,
+          i.value_size,
+          is_null,
+          ptr_id);
+        i.value_null = is_null;
+        grew = grew || (cap != i.value_value.capacity ());
+      }
+      else
+        throw null_pointer ();
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  init (value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // value
+    //
+    {
+      typedef object_traits< ::bpkg::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > ptr_traits;
+
+      if (i.value_null)
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_value (
+          ptr_id,
+          i.value_value,
+          i.value_size,
+          i.value_null);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<sqlite::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  insert (const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  select (value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::complements_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  // prerequisites
+  //
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"repository_fragment_prerequisites\".\"prerequisite\" "
+  "FROM \"main\".\"repository_fragment_prerequisites\" "
+  "WHERE \"main\".\"repository_fragment_prerequisites\".\"repository_fragment\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"repository_fragment_prerequisites\" "
+  "(\"repository_fragment\", "
+  "\"prerequisite\") "
+  "VALUES "
+  "(?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"repository_fragment_prerequisites\" "
+  "WHERE \"repository_fragment\"=?";
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // value
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = d.value_value.data ();
+    b[n].size = &d.value_size;
+    b[n].capacity = d.value_value.capacity ();
+    b[n].is_null = &d.value_null;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // value
+    //
+    if (t[0UL])
+    {
+      i.value_value.capacity (i.value_size);
+      grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  init (data_image_type& i,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // value
+    //
+    {
+      typedef object_traits< ::bpkg::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > wptr_traits;
+      typedef odb::pointer_traits< wptr_traits::strong_pointer_type > ptr_traits;
+
+      wptr_traits::strong_pointer_type sp (wptr_traits::lock (v));
+      bool is_null (ptr_traits::null_ptr (sp));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (sp));
+
+        std::size_t cap (i.value_value.capacity ());
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_image (
+          i.value_value,
+          i.value_size,
+          is_null,
+          ptr_id);
+        i.value_null = is_null;
+        grew = grew || (cap != i.value_value.capacity ());
+      }
+      else
+        throw null_pointer ();
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  init (value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // value
+    //
+    {
+      typedef object_traits< ::bpkg::repository > obj_traits;
+      typedef odb::pointer_traits< value_type > ptr_traits;
+
+      if (i.value_null)
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_value (
+          ptr_id,
+          i.value_value,
+          i.value_size,
+          i.value_null);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<sqlite::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  insert (const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  select (value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::prerequisites_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::id_type
+  access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  id (const image_type& i)
+  {
+    sqlite::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        id,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // location
+    //
+    if (composite_value_traits< ::bpkg::_repository_location, id_sqlite >::grow (
+          i.location_value, t + 1UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+
+    // name
+    //
+    if (sk != statement_update)
+    {
+      b[n].type = sqlite::image_traits<
+        ::std::string,
+        sqlite::id_text>::bind_value;
+      b[n].buffer = i.name_value.data ();
+      b[n].size = &i.name_size;
+      b[n].capacity = i.name_value.capacity ();
+      b[n].is_null = &i.name_null;
+      n++;
+    }
+
+    // location
+    //
+    composite_value_traits< ::bpkg::_repository_location, id_sqlite >::bind (
+      b + n, i.location_value, sk);
+    n += 2UL;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  bind (sqlite::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.id_value.data ();
+    b[n].size = &i.id_size;
+    b[n].capacity = i.id_value.capacity ();
+    b[n].is_null = &i.id_null;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  init (image_type& i,
+        const object_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    if (sk == statement_insert)
+    {
+      ::std::string const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // location
+    //
+    {
+      ::bpkg::repository_location const& v =
+        o.location;
+
+      // From package.hxx:368:14
+      ::bpkg::_repository_location const& vt =
+        bpkg::_repository_location 
+      {
+         (v).url (), (v).empty () ? bpkg::repository_type::pkg : (v).type () 
+      };
+
+
+      if (composite_value_traits< ::bpkg::_repository_location, id_sqlite >::init (
+            i.location_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // location
+    //
+    {
+      // From package.hxx:437:7
+      ::bpkg::repository_location v;
+
+      ::bpkg::_repository_location vt;
+
+      composite_value_traits< ::bpkg::_repository_location, id_sqlite >::init (
+        vt,
+        i.location_value,
+        db);
+
+      // From package.hxx:368:14
+      v = bpkg::repository_location (std::move ((vt).url), (vt).type);
+      // From package.hxx:437:7
+      o.location = std::move (v);
+      assert (o.name == o.location.canonical_name ());
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    {
+      bool is_null (false);
+      std::size_t cap (i.id_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.id_value,
+        i.id_size,
+        is_null,
+        id);
+      i.id_null = is_null;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::persist_statement[] =
+  "INSERT INTO \"main\".\"repository_fragment\" "
+  "(\"name\", "
+  "\"url\", "
+  "\"type\") "
+  "VALUES "
+  "(?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::find_statement[] =
+  "SELECT "
+  "\"main\".\"repository_fragment\".\"name\", "
+  "\"main\".\"repository_fragment\".\"url\", "
+  "\"main\".\"repository_fragment\".\"type\" "
+  "FROM \"main\".\"repository_fragment\" "
+  "WHERE \"main\".\"repository_fragment\".\"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::update_statement[] =
+  "UPDATE \"main\".\"repository_fragment\" "
+  "SET "
+  "\"url\"=?, "
+  "\"type\"=? "
+  "WHERE \"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::erase_statement[] =
+  "DELETE FROM \"main\".\"repository_fragment\" "
+  "WHERE \"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::query_statement[] =
+  "SELECT "
+  "\"main\".\"repository_fragment\".\"name\", "
+  "\"main\".\"repository_fragment\".\"url\", "
+  "\"main\".\"repository_fragment\".\"type\" "
+  "FROM \"main\".\"repository_fragment\"";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::erase_query_statement[] =
+  "DELETE FROM \"main\".\"repository_fragment\"";
+
+  const char access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::table_name[] =
+  "\"main\".\"repository_fragment\"";
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  persist (database& db, const object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      ::bpkg::repository_fragment::dependencies const& v =
+        obj.complements;
+
+      complements_traits::persist (
+        v,
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      ::bpkg::repository_fragment::dependencies const& v =
+        obj.prerequisites;
+
+      prerequisites_traits::persist (
+        v,
+        esc.prerequisites);
+    }
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace sqlite;
+    using sqlite::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    sqlite::connection& conn (tr.connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      ::bpkg::repository_fragment::dependencies const& v =
+        obj.complements;
+
+      complements_traits::update (
+        v,
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      ::bpkg::repository_fragment::dependencies const& v =
+        obj.prerequisites;
+
+      prerequisites_traits::update (
+        v,
+        esc.prerequisites);
+    }
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      complements_traits::erase (
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      prerequisites_traits::erase (
+        esc.prerequisites);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::pointer_type
+  access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  find (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace sqlite;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // complements
+    //
+    {
+      ::bpkg::repository_fragment::dependencies& v =
+        obj.complements;
+
+      complements_traits::load (
+        v,
+        esc.complements);
+    }
+
+    // prerequisites
+    //
+    {
+      ::bpkg::repository_fragment::dependencies& v =
+        obj.prerequisites;
+
+      prerequisites_traits::load (
+        v,
+        esc.prerequisites);
+    }
+  }
+
+  result< access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::object_type >
+  access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) sqlite::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  erase_query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      text,
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // repository_fragment_count
+  //
+
+  bool access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = false;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      sqlite::value_traits<
+          ::std::size_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "count(*) ");
+
+    r += "FROM \"main\".\"repository_fragment\"";
+
+    query_base_type c (
+      // From package.hxx:452:5
+      query_columns::name != "" && (q.empty () ? query_base_type::true_expr : q));
+
+    c.optimize ();
+
+    if (!c.empty ())
+    {
+      r += " ";
+      r += c.clause_prefix ();
+      r += c;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // fragment_type
+  //
+
+  bool access::composite_value_traits< ::bpkg::repository::fragment_type, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // friendly_name
+    //
+    if (t[0UL])
+    {
+      i.friendly_name_value.capacity (i.friendly_name_size);
+      grew = true;
+    }
+
+    // fragment
+    //
+    if (t[1UL])
+    {
+      i.fragment_value.capacity (i.fragment_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::repository::fragment_type, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // friendly_name
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.friendly_name_value.data ();
+    b[n].size = &i.friendly_name_size;
+    b[n].capacity = i.friendly_name_value.capacity ();
+    b[n].is_null = &i.friendly_name_null;
+    n++;
+
+    // fragment
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.fragment_value.data ();
+    b[n].size = &i.fragment_size;
+    b[n].capacity = i.fragment_value.capacity ();
+    b[n].is_null = &i.fragment_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::repository::fragment_type, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // friendly_name
+    //
+    {
+      ::std::string const& v =
+        o.friendly_name;
+
+      bool is_null (false);
+      std::size_t cap (i.friendly_name_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.friendly_name_value,
+        i.friendly_name_size,
+        is_null,
+        v);
+      i.friendly_name_null = is_null;
+      grew = grew || (cap != i.friendly_name_value.capacity ());
+    }
+
+    // fragment
+    //
+    {
+      ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment > const& v =
+        o.fragment;
+
+      typedef object_traits< ::bpkg::repository_fragment > obj_traits;
+      typedef odb::pointer_traits< ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment > > ptr_traits;
+
+      bool is_null (ptr_traits::null_ptr (v));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (v));
+
+        std::size_t cap (i.fragment_value.capacity ());
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_image (
+          i.fragment_value,
+          i.fragment_size,
+          is_null,
+          ptr_id);
+        i.fragment_null = is_null;
+        grew = grew || (cap != i.fragment_value.capacity ());
+      }
+      else
+        i.fragment_null = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::repository::fragment_type, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // friendly_name
+    //
+    {
+      ::std::string& v =
+        o.friendly_name;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.friendly_name_value,
+        i.friendly_name_size,
+        i.friendly_name_null);
+    }
+
+    // fragment
+    //
+    {
+      ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment >& v =
+        o.fragment;
+
+      typedef object_traits< ::bpkg::repository_fragment > obj_traits;
+      typedef odb::pointer_traits< ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment > > ptr_traits;
+
+      if (i.fragment_null)
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_value (
+          ptr_id,
+          i.fragment_value,
+          i.fragment_size,
+          i.fragment_null);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<sqlite::database*> (db), ptr_id);
+      }
+    }
+  }
+
+  // repository
+  //
+
+  struct access::object_traits_impl< ::bpkg::repository, id_sqlite >::extra_statement_cache_type
+  {
+    sqlite::container_statements_impl< fragments_traits > fragments;
+
+    extra_statement_cache_type (
+      sqlite::connection& c,
+      image_type&,
+      id_image_type&,
+      sqlite::binding& id,
+      sqlite::binding&)
+    : fragments (c, id)
+    {
+    }
+  };
+
+  // fragments
+  //
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"repository_fragments\".\"index\", "
+  "\"main\".\"repository_fragments\".\"friendly_name\", "
+  "\"main\".\"repository_fragments\".\"fragment\" "
+  "FROM \"main\".\"repository_fragments\" "
+  "WHERE \"main\".\"repository_fragments\".\"repository\"=? ORDER BY \"main\".\"repository_fragments\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"repository_fragments\" "
+  "(\"repository\", "
+  "\"index\", "
+  "\"friendly_name\", "
+  "\"fragment\") "
+  "VALUES "
+  "(?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"repository_fragments\" "
+  "WHERE \"repository\"=?";
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::fragments_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  access::object_traits_impl< ::bpkg::repository, id_sqlite >::id_type
+  access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  id (const image_type& i)
+  {
+    sqlite::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        id,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // location
+    //
+    if (composite_value_traits< ::bpkg::_repository_location, id_sqlite >::grow (
+          i.location_value, t + 1UL))
+      grew = true;
+
+    // certificate
+    //
+    if (t[3UL])
+    {
+      i.certificate_value.capacity (i.certificate_size);
+      grew = true;
+    }
+
+    // local
+    //
+    t[4UL] = false;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+
+    // name
+    //
+    if (sk != statement_update)
+    {
+      b[n].type = sqlite::image_traits<
+        ::std::string,
+        sqlite::id_text>::bind_value;
+      b[n].buffer = i.name_value.data ();
+      b[n].size = &i.name_size;
+      b[n].capacity = i.name_value.capacity ();
+      b[n].is_null = &i.name_null;
+      n++;
+    }
+
+    // location
+    //
+    composite_value_traits< ::bpkg::_repository_location, id_sqlite >::bind (
+      b + n, i.location_value, sk);
+    n += 2UL;
+
+    // certificate
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.certificate_value.data ();
+    b[n].size = &i.certificate_size;
+    b[n].capacity = i.certificate_value.capacity ();
+    b[n].is_null = &i.certificate_null;
+    n++;
+
+    // local
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.local_value;
+    b[n].is_null = &i.local_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  bind (sqlite::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.id_value.data ();
+    b[n].size = &i.id_size;
+    b[n].capacity = i.id_value.capacity ();
+    b[n].is_null = &i.id_null;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  init (image_type& i,
+        const object_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    if (sk == statement_insert)
+    {
+      ::std::string const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // location
+    //
+    {
+      ::bpkg::repository_location const& v =
+        o.location;
+
+      // From package.hxx:368:14
+      ::bpkg::_repository_location const& vt =
+        bpkg::_repository_location 
+      {
+         (v).url (), (v).empty () ? bpkg::repository_type::pkg : (v).type () 
+      };
+
+
+      if (composite_value_traits< ::bpkg::_repository_location, id_sqlite >::init (
+            i.location_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    // certificate
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.certificate;
+
+      bool is_null (true);
+      std::size_t cap (i.certificate_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.certificate_value,
+        i.certificate_size,
+        is_null,
+        v);
+      i.certificate_null = is_null;
+      grew = grew || (cap != i.certificate_value.capacity ());
+    }
+
+    // local
+    //
+    {
+      ::butl::optional< bool > const& v =
+        o.local;
+
+      bool is_null (true);
+      sqlite::value_traits<
+          ::butl::optional< bool >,
+          sqlite::id_integer >::set_image (
+        i.local_value,
+        is_null,
+        v);
+      i.local_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // location
+    //
+    {
+      // From package.hxx:501:7
+      ::bpkg::repository_location v;
+
+      ::bpkg::_repository_location vt;
+
+      composite_value_traits< ::bpkg::_repository_location, id_sqlite >::init (
+        vt,
+        i.location_value,
+        db);
+
+      // From package.hxx:368:14
+      v = bpkg::repository_location (std::move ((vt).url), (vt).type);
+      // From package.hxx:501:7
+      o.location = std::move (v);
+      assert (o.name == o.location.canonical_name ());
+    }
+
+    // certificate
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.certificate;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.certificate_value,
+        i.certificate_size,
+        i.certificate_null);
+    }
+
+    // local
+    //
+    {
+      ::butl::optional< bool >& v =
+        o.local;
+
+      sqlite::value_traits<
+          ::butl::optional< bool >,
+          sqlite::id_integer >::set_value (
+        v,
+        i.local_value,
+        i.local_null);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    {
+      bool is_null (false);
+      std::size_t cap (i.id_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.id_value,
+        i.id_size,
+        is_null,
+        id);
+      i.id_null = is_null;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::persist_statement[] =
+  "INSERT INTO \"main\".\"repository\" "
+  "(\"name\", "
+  "\"url\", "
+  "\"type\", "
+  "\"certificate\", "
+  "\"local\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::find_statement[] =
+  "SELECT "
+  "\"main\".\"repository\".\"name\", "
+  "\"main\".\"repository\".\"url\", "
+  "\"main\".\"repository\".\"type\", "
+  "\"main\".\"repository\".\"certificate\", "
+  "\"main\".\"repository\".\"local\" "
+  "FROM \"main\".\"repository\" "
+  "WHERE \"main\".\"repository\".\"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::update_statement[] =
+  "UPDATE \"main\".\"repository\" "
+  "SET "
+  "\"url\"=?, "
+  "\"type\"=?, "
+  "\"certificate\"=?, "
+  "\"local\"=? "
+  "WHERE \"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::erase_statement[] =
+  "DELETE FROM \"main\".\"repository\" "
+  "WHERE \"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::query_statement[] =
+  "SELECT "
+  "\"main\".\"repository\".\"name\", "
+  "\"main\".\"repository\".\"url\", "
+  "\"main\".\"repository\".\"type\", "
+  "\"main\".\"repository\".\"certificate\", "
+  "\"main\".\"repository\".\"local\" "
+  "FROM \"main\".\"repository\"";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::erase_query_statement[] =
+  "DELETE FROM \"main\".\"repository\"";
+
+  const char access::object_traits_impl< ::bpkg::repository, id_sqlite >::table_name[] =
+  "\"main\".\"repository\"";
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  persist (database& db, const object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // fragments
+    //
+    {
+      ::bpkg::repository::fragments_type const& v =
+        obj.fragments;
+
+      fragments_traits::persist (
+        v,
+        esc.fragments);
+    }
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace sqlite;
+    using sqlite::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    sqlite::connection& conn (tr.connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // fragments
+    //
+    {
+      ::bpkg::repository::fragments_type const& v =
+        obj.fragments;
+
+      fragments_traits::update (
+        v,
+        esc.fragments);
+    }
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // fragments
+    //
+    {
+      fragments_traits::erase (
+        esc.fragments);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::bpkg::repository, id_sqlite >::pointer_type
+  access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  find (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace sqlite;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // fragments
+    //
+    {
+      ::bpkg::repository::fragments_type& v =
+        obj.fragments;
+
+      fragments_traits::load (
+        v,
+        esc.fragments);
+    }
+  }
+
+  result< access::object_traits_impl< ::bpkg::repository, id_sqlite >::object_type >
+  access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) sqlite::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  erase_query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      text,
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // repository_count
+  //
+
+  bool access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = false;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      sqlite::value_traits<
+          ::std::size_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "count(*) ");
+
+    r += "FROM \"main\".\"repository\"";
+
+    query_base_type c (
+      // From package.hxx:512:38
+      query_columns::name != "" && (q.empty () ? query_base_type::true_expr : q));
+
+    c.optimize ();
+
+    if (!c.empty ())
+    {
+      r += " ";
+      r += c.clause_prefix ();
+      r += c;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // package_location
+  //
+
+  bool access::composite_value_traits< ::bpkg::package_location, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // repository_fragment
+    //
+    if (t[0UL])
+    {
+      i.repository_fragment_value.capacity (i.repository_fragment_size);
+      grew = true;
+    }
+
+    // location
+    //
+    if (t[1UL])
+    {
+      i.location_value.capacity (i.location_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::package_location, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // repository_fragment
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.repository_fragment_value.data ();
+    b[n].size = &i.repository_fragment_size;
+    b[n].capacity = i.repository_fragment_value.capacity ();
+    b[n].is_null = &i.repository_fragment_null;
+    n++;
+
+    // location
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.location_value.data ();
+    b[n].size = &i.location_size;
+    b[n].capacity = i.location_value.capacity ();
+    b[n].is_null = &i.location_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::package_location, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // repository_fragment
+    //
+    {
+      ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment > const& v =
+        o.repository_fragment;
+
+      typedef object_traits< ::bpkg::repository_fragment > obj_traits;
+      typedef odb::pointer_traits< ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment > > ptr_traits;
+
+      bool is_null (ptr_traits::null_ptr (v));
+      if (!is_null)
+      {
+        const obj_traits::id_type& ptr_id (
+          ptr_traits::object_id< ptr_traits::element_type  > (v));
+
+        std::size_t cap (i.repository_fragment_value.capacity ());
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_image (
+          i.repository_fragment_value,
+          i.repository_fragment_size,
+          is_null,
+          ptr_id);
+        i.repository_fragment_null = is_null;
+        grew = grew || (cap != i.repository_fragment_value.capacity ());
+      }
+      else
+        i.repository_fragment_null = true;
+    }
+
+    // location
+    //
+    {
+      ::butl::path const& v =
+        o.location;
+
+      // From package.hxx:50:14
+      ::std::string const& vt =
+        (v).representation ();
+
+      bool is_null (false);
+      std::size_t cap (i.location_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.location_value,
+        i.location_size,
+        is_null,
+        vt);
+      i.location_null = is_null;
+      grew = grew || (cap != i.location_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::package_location, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // repository_fragment
+    //
+    {
+      ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment >& v =
+        o.repository_fragment;
+
+      typedef object_traits< ::bpkg::repository_fragment > obj_traits;
+      typedef odb::pointer_traits< ::bpkg::lazy_shared_ptr< ::bpkg::repository_fragment > > ptr_traits;
+
+      if (i.repository_fragment_null)
+        v = ptr_traits::pointer_type ();
+      else
+      {
+        obj_traits::id_type ptr_id;
+        sqlite::value_traits<
+            obj_traits::id_type,
+            sqlite::id_text >::set_value (
+          ptr_id,
+          i.repository_fragment_value,
+          i.repository_fragment_size,
+          i.repository_fragment_null);
+
+        v = ptr_traits::pointer_type (
+          *static_cast<sqlite::database*> (db), ptr_id);
+      }
+    }
+
+    // location
+    //
+    {
+      ::butl::path& v =
+        o.location;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.location_value,
+        i.location_size,
+        i.location_null);
+
+      // From package.hxx:50:14
+      v = bpkg::path (vt);
+    }
+  }
+
+  // dependency_alternatives_ex
+  //
+
+  bool access::composite_value_traits< ::bpkg::dependency_alternatives_ex, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // dependency_alternatives base
+    //
+    if (composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::grow (
+          i, t + 0UL))
+      grew = true;
+
+    // type
+    //
+    if (t[2UL])
+    {
+      i.type_value.capacity (i.type_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency_alternatives_ex, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // dependency_alternatives base
+    //
+    composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::bind (b + n, i, sk);
+    n += 2UL;
+
+    // type
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::optional_string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.type_value.data ();
+    b[n].size = &i.type_size;
+    b[n].capacity = i.type_value.capacity ();
+    b[n].is_null = &i.type_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::dependency_alternatives_ex, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // dependency_alternatives base
+    //
+    if (composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::init (i, o, sk))
+      grew = true;
+
+    // type
+    //
+    {
+      ::butl::optional< ::bpkg::test_dependency_type > const& v =
+        o.type;
+
+      // From package.hxx:633:14
+      ::bpkg::optional_string const& vt =
+        (v) ? to_string ( * (v)) : bpkg::optional_string ();
+
+      bool is_null (true);
+      std::size_t cap (i.type_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_image (
+        i.type_value,
+        i.type_size,
+        is_null,
+        vt);
+      i.type_null = is_null;
+      grew = grew || (cap != i.type_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::dependency_alternatives_ex, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // dependency_alternatives base
+    //
+    composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::init (o, i, db);
+
+    // type
+    //
+    {
+      ::butl::optional< ::bpkg::test_dependency_type >& v =
+        o.type;
+
+      ::bpkg::optional_string vt;
+
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.type_value,
+        i.type_size,
+        i.type_null);
+
+      // From package.hxx:633:14
+      v = (vt) ? bpkg::to_test_dependency_type ( * (vt)) : bpkg::optional_test_dependency_type ();
+    }
+  }
+
+  // available_package_id
+  //
+
+  bool access::composite_value_traits< ::bpkg::available_package_id, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // version
+    //
+    if (composite_value_traits< ::bpkg::canonical_version, id_sqlite >::grow (
+          i.version_value, t + 1UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::available_package_id, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::package_name,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // version
+    //
+    composite_value_traits< ::bpkg::canonical_version, id_sqlite >::bind (
+      b + n, i.version_value, sk);
+    n += 5UL;
+  }
+
+  bool access::composite_value_traits< ::bpkg::available_package_id, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    {
+      ::bpkg::package_name const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // version
+    //
+    {
+      ::bpkg::canonical_version const& v =
+        o.version;
+
+      if (composite_value_traits< ::bpkg::canonical_version, id_sqlite >::init (
+            i.version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::available_package_id, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::bpkg::package_name& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // version
+    //
+    {
+      ::bpkg::canonical_version& v =
+        o.version;
+
+      composite_value_traits< ::bpkg::canonical_version, id_sqlite >::init (
+        v,
+        i.version_value,
+        db);
+    }
+  }
+
+  // _dependency_alternative_key
+  //
+
+  bool access::composite_value_traits< ::bpkg::available_package::_dependency_alternative_key, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // outer
+    //
+    t[0UL] = false;
+
+    // inner
+    //
+    t[1UL] = false;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::available_package::_dependency_alternative_key, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // outer
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.outer_value;
+    b[n].is_null = &i.outer_null;
+    n++;
+
+    // inner
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.inner_value;
+    b[n].is_null = &i.inner_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::available_package::_dependency_alternative_key, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // outer
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_key::outer_type const& v =
+        o.outer;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_key::outer_type,
+          sqlite::id_integer >::set_image (
+        i.outer_value,
+        is_null,
+        v);
+      i.outer_null = is_null;
+    }
+
+    // inner
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_key::inner_type const& v =
+        o.inner;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_key::inner_type,
+          sqlite::id_integer >::set_image (
+        i.inner_value,
+        is_null,
+        v);
+      i.inner_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::available_package::_dependency_alternative_key, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // outer
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_key::outer_type& v =
+        o.outer;
+
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_key::outer_type,
+          sqlite::id_integer >::set_value (
+        v,
+        i.outer_value,
+        i.outer_null);
+    }
+
+    // inner
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_key::inner_type& v =
+        o.inner;
+
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_key::inner_type,
+          sqlite::id_integer >::set_value (
+        v,
+        i.inner_value,
+        i.inner_null);
+    }
+  }
+
+  // _dependency_key
+  //
+
+  bool access::composite_value_traits< ::bpkg::available_package::_dependency_key, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // outer
+    //
+    t[0UL] = false;
+
+    // middle
+    //
+    t[1UL] = false;
+
+    // inner
+    //
+    t[2UL] = false;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::available_package::_dependency_key, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // outer
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.outer_value;
+    b[n].is_null = &i.outer_null;
+    n++;
+
+    // middle
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.middle_value;
+    b[n].is_null = &i.middle_null;
+    n++;
+
+    // inner
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.inner_value;
+    b[n].is_null = &i.inner_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::available_package::_dependency_key, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // outer
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::outer_type const& v =
+        o.outer;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::outer_type,
+          sqlite::id_integer >::set_image (
+        i.outer_value,
+        is_null,
+        v);
+      i.outer_null = is_null;
+    }
+
+    // middle
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::middle_type const& v =
+        o.middle;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::middle_type,
+          sqlite::id_integer >::set_image (
+        i.middle_value,
+        is_null,
+        v);
+      i.middle_null = is_null;
+    }
+
+    // inner
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::inner_type const& v =
+        o.inner;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::inner_type,
+          sqlite::id_integer >::set_image (
+        i.inner_value,
+        is_null,
+        v);
+      i.inner_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::available_package::_dependency_key, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // outer
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::outer_type& v =
+        o.outer;
+
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::outer_type,
+          sqlite::id_integer >::set_value (
+        v,
+        i.outer_value,
+        i.outer_null);
+    }
+
+    // middle
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::middle_type& v =
+        o.middle;
+
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::middle_type,
+          sqlite::id_integer >::set_value (
+        v,
+        i.middle_value,
+        i.middle_null);
+    }
+
+    // inner
+    //
+    {
+      ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::inner_type& v =
+        o.inner;
+
+      sqlite::value_traits<
+          ::bpkg::available_package::_dependency_alternative_dependencies_type::key_type::inner_type,
+          sqlite::id_integer >::set_value (
+        v,
+        i.inner_value,
+        i.inner_null);
+    }
+  }
+
+  // available_package
+  //
+
+  struct access::object_traits_impl< ::bpkg::available_package, id_sqlite >::extra_statement_cache_type
+  {
+    sqlite::container_statements_impl< languages_traits > languages;
+    sqlite::container_statements_impl< locations_traits > locations;
+    sqlite::container_statements_impl< dependencies_traits > dependencies;
+    sqlite::container_statements_impl< dependency_alternatives_traits > dependency_alternatives;
+    sqlite::container_statements_impl< dependency_alternative_dependencies_traits > dependency_alternative_dependencies;
+    sqlite::container_statements_impl< tests_traits > tests;
+    sqlite::container_statements_impl< buildfiles_traits > buildfiles;
+    sqlite::container_statements_impl< distribution_values_traits > distribution_values;
+
+    sqlite::section_statements< ::bpkg::available_package, languages_section_traits > languages_section;
+
+    extra_statement_cache_type (
+      sqlite::connection& c,
+      image_type& im,
+      id_image_type& idim,
+      sqlite::binding& id,
+      sqlite::binding& idv)
+    : languages (c, id),
+      locations (c, id),
+      dependencies (c, id),
+      dependency_alternatives (c, id),
+      dependency_alternative_dependencies (c, id),
+      tests (c, id),
+      buildfiles (c, id),
+      distribution_values (c, id),
+      languages_section (c, im, idim, id, idv)
+    {
+    }
+  };
+
+  // languages
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_languages\".\"index\", "
+  "\"main\".\"available_package_languages\".\"language_name\", "
+  "\"main\".\"available_package_languages\".\"language_impl\" "
+  "FROM \"main\".\"available_package_languages\" "
+  "WHERE \"main\".\"available_package_languages\".\"name\"=? AND \"main\".\"available_package_languages\".\"version_epoch\"=? AND \"main\".\"available_package_languages\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_languages\".\"version_canonical_release\"=? AND \"main\".\"available_package_languages\".\"version_revision\"=? AND \"main\".\"available_package_languages\".\"version_iteration\"=? ORDER BY \"main\".\"available_package_languages\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_languages\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"index\", "
+  "\"language_name\", "
+  "\"language_impl\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_languages\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // locations
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_locations\".\"repository_fragment\", "
+  "\"main\".\"available_package_locations\".\"location\" "
+  "FROM \"main\".\"available_package_locations\" "
+  "WHERE \"main\".\"available_package_locations\".\"name\"=? AND \"main\".\"available_package_locations\".\"version_epoch\"=? AND \"main\".\"available_package_locations\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_locations\".\"version_canonical_release\"=? AND \"main\".\"available_package_locations\".\"version_revision\"=? AND \"main\".\"available_package_locations\".\"version_iteration\"=?";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_locations\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"repository_fragment\", "
+  "\"location\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_locations\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 0UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  init (data_image_type& i,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  init (value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  insert (index_type, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  select (index_type&, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = false;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = false;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = false;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::locations_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = false;
+    container_traits_type::erase (fs);
+  }
+
+  // dependencies
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_dependencies\".\"index\", "
+  "\"main\".\"available_package_dependencies\".\"buildtime\", "
+  "\"main\".\"available_package_dependencies\".\"comment\", "
+  "\"main\".\"available_package_dependencies\".\"type\" "
+  "FROM \"main\".\"available_package_dependencies\" "
+  "WHERE \"main\".\"available_package_dependencies\".\"name\"=? AND \"main\".\"available_package_dependencies\".\"version_epoch\"=? AND \"main\".\"available_package_dependencies\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_dependencies\".\"version_canonical_release\"=? AND \"main\".\"available_package_dependencies\".\"version_revision\"=? AND \"main\".\"available_package_dependencies\".\"version_iteration\"=? ORDER BY \"main\".\"available_package_dependencies\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_dependencies\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"index\", "
+  "\"buildtime\", "
+  "\"comment\", "
+  "\"type\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_dependencies\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependencies_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // dependency_alternatives
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_dependency_alternatives\".\"dependency_index\", "
+  "\"main\".\"available_package_dependency_alternatives\".\"index\", "
+  "\"main\".\"available_package_dependency_alternatives\".\"enable\", "
+  "\"main\".\"available_package_dependency_alternatives\".\"reflect\", "
+  "\"main\".\"available_package_dependency_alternatives\".\"prefer\", "
+  "\"main\".\"available_package_dependency_alternatives\".\"accept\", "
+  "\"main\".\"available_package_dependency_alternatives\".\"require\" "
+  "FROM \"main\".\"available_package_dependency_alternatives\" "
+  "WHERE \"main\".\"available_package_dependency_alternatives\".\"name\"=? AND \"main\".\"available_package_dependency_alternatives\".\"version_epoch\"=? AND \"main\".\"available_package_dependency_alternatives\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_dependency_alternatives\".\"version_canonical_release\"=? AND \"main\".\"available_package_dependency_alternatives\".\"version_revision\"=? AND \"main\".\"available_package_dependency_alternatives\".\"version_iteration\"=?";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_dependency_alternatives\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"dependency_index\", "
+  "\"index\", "
+  "\"enable\", "
+  "\"reflect\", "
+  "\"prefer\", "
+  "\"accept\", "
+  "\"require\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_dependency_alternatives\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // key
+    //
+    composite_value_traits< key_type, id_sqlite >::bind (
+      b + n, d.key_value, sk);
+    n += 2UL;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // key
+    //
+    if (composite_value_traits< key_type, id_sqlite >::grow (
+          i.key_value, t + 0UL))
+      grew = true;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 2UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  init (data_image_type& i,
+        const key_type* k,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // key
+    //
+    if (k != 0)
+    {
+      composite_value_traits< key_type, id_sqlite >::init (
+        i.key_value,
+        *k,
+        sk);
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  init (key_type& k,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // key
+    //
+    {
+      composite_value_traits< key_type, id_sqlite >::init (
+        k,
+        i.key_value,
+        db);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  insert (const key_type& k, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &k, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  select (key_type& k, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (k, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternatives_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  // dependency_alternative_dependencies
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dependency_index\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"alternative_index\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"index\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_name\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_version_epoch\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_version_canonical_upstream\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_version_canonical_release\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_version_revision\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_version_iteration\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_version_upstream\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_version_release\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_version_epoch\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_version_canonical_upstream\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_version_canonical_release\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_version_revision\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_version_iteration\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_version_upstream\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_version_release\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_min_open\", "
+  "\"main\".\"available_package_dependency_alternative_dependencies\".\"dep_max_open\" "
+  "FROM \"main\".\"available_package_dependency_alternative_dependencies\" "
+  "WHERE \"main\".\"available_package_dependency_alternative_dependencies\".\"name\"=? AND \"main\".\"available_package_dependency_alternative_dependencies\".\"version_epoch\"=? AND \"main\".\"available_package_dependency_alternative_dependencies\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_dependency_alternative_dependencies\".\"version_canonical_release\"=? AND \"main\".\"available_package_dependency_alternative_dependencies\".\"version_revision\"=? AND \"main\".\"available_package_dependency_alternative_dependencies\".\"version_iteration\"=?";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_dependency_alternative_dependencies\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"dependency_index\", "
+  "\"alternative_index\", "
+  "\"index\", "
+  "\"dep_name\", "
+  "\"dep_min_version_epoch\", "
+  "\"dep_min_version_canonical_upstream\", "
+  "\"dep_min_version_canonical_release\", "
+  "\"dep_min_version_revision\", "
+  "\"dep_min_version_iteration\", "
+  "\"dep_min_version_upstream\", "
+  "\"dep_min_version_release\", "
+  "\"dep_max_version_epoch\", "
+  "\"dep_max_version_canonical_upstream\", "
+  "\"dep_max_version_canonical_release\", "
+  "\"dep_max_version_revision\", "
+  "\"dep_max_version_iteration\", "
+  "\"dep_max_version_upstream\", "
+  "\"dep_max_version_release\", "
+  "\"dep_min_open\", "
+  "\"dep_max_open\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_dependency_alternative_dependencies\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // key
+    //
+    composite_value_traits< key_type, id_sqlite >::bind (
+      b + n, d.key_value, sk);
+    n += 3UL;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // key
+    //
+    if (composite_value_traits< key_type, id_sqlite >::grow (
+          i.key_value, t + 0UL))
+      grew = true;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 3UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  init (data_image_type& i,
+        const key_type* k,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // key
+    //
+    if (k != 0)
+    {
+      composite_value_traits< key_type, id_sqlite >::init (
+        i.key_value,
+        *k,
+        sk);
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  init (key_type& k,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // key
+    //
+    {
+      composite_value_traits< key_type, id_sqlite >::init (
+        k,
+        i.key_value,
+        db);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  insert (const key_type& k, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &k, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  select (key_type& k, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (k, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::dependency_alternative_dependencies_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  // tests
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_tests\".\"index\", "
+  "\"main\".\"available_package_tests\".\"test_name\", "
+  "\"main\".\"available_package_tests\".\"test_min_version_epoch\", "
+  "\"main\".\"available_package_tests\".\"test_min_version_canonical_upstream\", "
+  "\"main\".\"available_package_tests\".\"test_min_version_canonical_release\", "
+  "\"main\".\"available_package_tests\".\"test_min_version_revision\", "
+  "\"main\".\"available_package_tests\".\"test_min_version_iteration\", "
+  "\"main\".\"available_package_tests\".\"test_min_version_upstream\", "
+  "\"main\".\"available_package_tests\".\"test_min_version_release\", "
+  "\"main\".\"available_package_tests\".\"test_max_version_epoch\", "
+  "\"main\".\"available_package_tests\".\"test_max_version_canonical_upstream\", "
+  "\"main\".\"available_package_tests\".\"test_max_version_canonical_release\", "
+  "\"main\".\"available_package_tests\".\"test_max_version_revision\", "
+  "\"main\".\"available_package_tests\".\"test_max_version_iteration\", "
+  "\"main\".\"available_package_tests\".\"test_max_version_upstream\", "
+  "\"main\".\"available_package_tests\".\"test_max_version_release\", "
+  "\"main\".\"available_package_tests\".\"test_min_open\", "
+  "\"main\".\"available_package_tests\".\"test_max_open\", "
+  "\"main\".\"available_package_tests\".\"test_type\", "
+  "\"main\".\"available_package_tests\".\"test_buildtime\", "
+  "\"main\".\"available_package_tests\".\"test_enable\", "
+  "\"main\".\"available_package_tests\".\"test_reflect\" "
+  "FROM \"main\".\"available_package_tests\" "
+  "WHERE \"main\".\"available_package_tests\".\"name\"=? AND \"main\".\"available_package_tests\".\"version_epoch\"=? AND \"main\".\"available_package_tests\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_tests\".\"version_canonical_release\"=? AND \"main\".\"available_package_tests\".\"version_revision\"=? AND \"main\".\"available_package_tests\".\"version_iteration\"=? ORDER BY \"main\".\"available_package_tests\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_tests\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"index\", "
+  "\"test_name\", "
+  "\"test_min_version_epoch\", "
+  "\"test_min_version_canonical_upstream\", "
+  "\"test_min_version_canonical_release\", "
+  "\"test_min_version_revision\", "
+  "\"test_min_version_iteration\", "
+  "\"test_min_version_upstream\", "
+  "\"test_min_version_release\", "
+  "\"test_max_version_epoch\", "
+  "\"test_max_version_canonical_upstream\", "
+  "\"test_max_version_canonical_release\", "
+  "\"test_max_version_revision\", "
+  "\"test_max_version_iteration\", "
+  "\"test_max_version_upstream\", "
+  "\"test_max_version_release\", "
+  "\"test_min_open\", "
+  "\"test_max_open\", "
+  "\"test_type\", "
+  "\"test_buildtime\", "
+  "\"test_enable\", "
+  "\"test_reflect\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_tests\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::tests_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // buildfiles
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_buildfiles\".\"index\", "
+  "\"main\".\"available_package_buildfiles\".\"path\", "
+  "\"main\".\"available_package_buildfiles\".\"content\" "
+  "FROM \"main\".\"available_package_buildfiles\" "
+  "WHERE \"main\".\"available_package_buildfiles\".\"name\"=? AND \"main\".\"available_package_buildfiles\".\"version_epoch\"=? AND \"main\".\"available_package_buildfiles\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_buildfiles\".\"version_canonical_release\"=? AND \"main\".\"available_package_buildfiles\".\"version_revision\"=? AND \"main\".\"available_package_buildfiles\".\"version_iteration\"=? ORDER BY \"main\".\"available_package_buildfiles\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_buildfiles\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"index\", "
+  "\"path\", "
+  "\"content\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_buildfiles\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::buildfiles_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // distribution_values
+  //
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"available_package_distribution_values\".\"index\", "
+  "\"main\".\"available_package_distribution_values\".\"dist_name\", "
+  "\"main\".\"available_package_distribution_values\".\"dist_value\" "
+  "FROM \"main\".\"available_package_distribution_values\" "
+  "WHERE \"main\".\"available_package_distribution_values\".\"name\"=? AND \"main\".\"available_package_distribution_values\".\"version_epoch\"=? AND \"main\".\"available_package_distribution_values\".\"version_canonical_upstream\"=? AND \"main\".\"available_package_distribution_values\".\"version_canonical_release\"=? AND \"main\".\"available_package_distribution_values\".\"version_revision\"=? AND \"main\".\"available_package_distribution_values\".\"version_iteration\"=? ORDER BY \"main\".\"available_package_distribution_values\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"available_package_distribution_values\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"index\", "
+  "\"dist_name\", "
+  "\"dist_value\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"available_package_distribution_values\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::distribution_values_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // languages_section
+  //
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_section_traits::
+  load (extra_statement_cache_type& esc, object_type& obj)
+  {
+    // languages
+    //
+    {
+      ::butl::small_vector< ::bpkg::language, 1 >& v =
+        obj.languages;
+
+      languages_traits::load (
+        v,
+        esc.languages);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::languages_section_traits::
+  update (extra_statement_cache_type& esc, const object_type& obj)
+  {
+    // languages
+    //
+    {
+      ::butl::small_vector< ::bpkg::language, 1 > const& v =
+        obj.languages;
+
+      languages_traits::update (
+        v,
+        esc.languages);
+    }
+  }
+
+  access::object_traits_impl< ::bpkg::available_package, id_sqlite >::id_type
+  access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  id (const image_type& i)
+  {
+    sqlite::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      composite_value_traits< ::bpkg::available_package_id, id_sqlite >::init (
+        id,
+        i.id_value,
+        db);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (composite_value_traits< ::bpkg::available_package_id, id_sqlite >::grow (
+          i.id_value, t + 0UL))
+      grew = true;
+
+    // version
+    //
+    if (composite_value_traits< ::bpkg::available_package::upstream_version_type, id_sqlite >::grow (
+          i.version_value, t + 6UL))
+      grew = true;
+
+    // upstream_version
+    //
+    if (t[8UL])
+    {
+      i.upstream_version_value.capacity (i.upstream_version_size);
+      grew = true;
+    }
+
+    // type
+    //
+    if (t[9UL])
+    {
+      i.type_value.capacity (i.type_size);
+      grew = true;
+    }
+
+    // project
+    //
+    if (t[10UL])
+    {
+      i.project_value.capacity (i.project_size);
+      grew = true;
+    }
+
+    // alt_naming
+    //
+    t[11UL] = false;
+
+    // bootstrap_build
+    //
+    if (t[12UL])
+    {
+      i.bootstrap_build_value.capacity (i.bootstrap_build_size);
+      grew = true;
+    }
+
+    // root_build
+    //
+    if (t[13UL])
+    {
+      i.root_build_value.capacity (i.root_build_size);
+      grew = true;
+    }
+
+    // sha256sum
+    //
+    if (t[14UL])
+    {
+      i.sha256sum_value.capacity (i.sha256sum_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      composite_value_traits< ::bpkg::available_package_id, id_sqlite >::bind (
+        b + n, i.id_value, sk);
+      n += 6UL;
+    }
+
+    // version
+    //
+    composite_value_traits< ::bpkg::available_package::upstream_version_type, id_sqlite >::bind (
+      b + n, i.version_value, sk);
+    n += 2UL;
+
+    // upstream_version
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.upstream_version_value.data ();
+    b[n].size = &i.upstream_version_size;
+    b[n].capacity = i.upstream_version_value.capacity ();
+    b[n].is_null = &i.upstream_version_null;
+    n++;
+
+    // type
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.type_value.data ();
+    b[n].size = &i.type_size;
+    b[n].capacity = i.type_value.capacity ();
+    b[n].is_null = &i.type_null;
+    n++;
+
+    // project
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::butl::project_name >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.project_value.data ();
+    b[n].size = &i.project_size;
+    b[n].capacity = i.project_value.capacity ();
+    b[n].is_null = &i.project_null;
+    n++;
+
+    // alt_naming
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.alt_naming_value;
+    b[n].is_null = &i.alt_naming_null;
+    n++;
+
+    // bootstrap_build
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.bootstrap_build_value.data ();
+    b[n].size = &i.bootstrap_build_size;
+    b[n].capacity = i.bootstrap_build_value.capacity ();
+    b[n].is_null = &i.bootstrap_build_null;
+    n++;
+
+    // root_build
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.root_build_value.data ();
+    b[n].size = &i.root_build_size;
+    b[n].capacity = i.root_build_value.capacity ();
+    b[n].is_null = &i.root_build_null;
+    n++;
+
+    // sha256sum
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.sha256sum_value.data ();
+    b[n].size = &i.sha256sum_size;
+    b[n].capacity = i.sha256sum_value.capacity ();
+    b[n].is_null = &i.sha256sum_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  bind (sqlite::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    sqlite::statement_kind sk (sqlite::statement_select);
+    composite_value_traits< ::bpkg::available_package_id, id_sqlite >::bind (
+      b + n, i.id_value, sk);
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  init (image_type& i,
+        const object_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::bpkg::available_package_id const& v =
+        o.id;
+
+      if (composite_value_traits< ::bpkg::available_package_id, id_sqlite >::init (
+            i.id_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // version
+    //
+    {
+      ::bpkg::available_package::upstream_version_type const& v =
+        o.version;
+
+      if (composite_value_traits< ::bpkg::available_package::upstream_version_type, id_sqlite >::init (
+            i.version_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    // upstream_version
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.upstream_version;
+
+      bool is_null (true);
+      std::size_t cap (i.upstream_version_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.upstream_version_value,
+        i.upstream_version_size,
+        is_null,
+        v);
+      i.upstream_version_null = is_null;
+      grew = grew || (cap != i.upstream_version_value.capacity ());
+    }
+
+    // type
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.type;
+
+      bool is_null (true);
+      std::size_t cap (i.type_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.type_value,
+        i.type_size,
+        is_null,
+        v);
+      i.type_null = is_null;
+      grew = grew || (cap != i.type_value.capacity ());
+    }
+
+    // project
+    //
+    {
+      ::butl::optional< ::butl::project_name > const& v =
+        o.project;
+
+      bool is_null (true);
+      std::size_t cap (i.project_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::butl::project_name >,
+          sqlite::id_text >::set_image (
+        i.project_value,
+        i.project_size,
+        is_null,
+        v);
+      i.project_null = is_null;
+      grew = grew || (cap != i.project_value.capacity ());
+    }
+
+    // alt_naming
+    //
+    {
+      ::butl::optional< bool > const& v =
+        o.alt_naming;
+
+      bool is_null (true);
+      sqlite::value_traits<
+          ::butl::optional< bool >,
+          sqlite::id_integer >::set_image (
+        i.alt_naming_value,
+        is_null,
+        v);
+      i.alt_naming_null = is_null;
+    }
+
+    // bootstrap_build
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.bootstrap_build;
+
+      bool is_null (true);
+      std::size_t cap (i.bootstrap_build_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.bootstrap_build_value,
+        i.bootstrap_build_size,
+        is_null,
+        v);
+      i.bootstrap_build_null = is_null;
+      grew = grew || (cap != i.bootstrap_build_value.capacity ());
+    }
+
+    // root_build
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.root_build;
+
+      bool is_null (true);
+      std::size_t cap (i.root_build_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.root_build_value,
+        i.root_build_size,
+        is_null,
+        v);
+      i.root_build_null = is_null;
+      grew = grew || (cap != i.root_build_value.capacity ());
+    }
+
+    // sha256sum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.sha256sum;
+
+      bool is_null (true);
+      std::size_t cap (i.sha256sum_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.sha256sum_value,
+        i.sha256sum_size,
+        is_null,
+        v);
+      i.sha256sum_null = is_null;
+      grew = grew || (cap != i.sha256sum_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::bpkg::available_package_id& v =
+        o.id;
+
+      composite_value_traits< ::bpkg::available_package_id, id_sqlite >::init (
+        v,
+        i.id_value,
+        db);
+    }
+
+    // version
+    //
+    {
+      // From package.hxx:830:32
+      ::bpkg::available_package::upstream_version_type v;
+
+      composite_value_traits< ::bpkg::available_package::upstream_version_type, id_sqlite >::init (
+        v,
+        i.version_value,
+        db);
+
+      // From package.hxx:830:32
+      o.version.init (o.id.version, (v));
+    }
+
+    // upstream_version
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.upstream_version;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.upstream_version_value,
+        i.upstream_version_size,
+        i.upstream_version_null);
+    }
+
+    // type
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.type;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.type_value,
+        i.type_size,
+        i.type_null);
+    }
+
+    // project
+    //
+    {
+      ::butl::optional< ::butl::project_name >& v =
+        o.project;
+
+      sqlite::value_traits<
+          ::butl::optional< ::butl::project_name >,
+          sqlite::id_text >::set_value (
+        v,
+        i.project_value,
+        i.project_size,
+        i.project_null);
+    }
+
+    // alt_naming
+    //
+    {
+      ::butl::optional< bool >& v =
+        o.alt_naming;
+
+      sqlite::value_traits<
+          ::butl::optional< bool >,
+          sqlite::id_integer >::set_value (
+        v,
+        i.alt_naming_value,
+        i.alt_naming_null);
+    }
+
+    // bootstrap_build
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.bootstrap_build;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.bootstrap_build_value,
+        i.bootstrap_build_size,
+        i.bootstrap_build_null);
+    }
+
+    // root_build
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.root_build;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.root_build_value,
+        i.root_build_size,
+        i.root_build_null);
+    }
+
+    // sha256sum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.sha256sum;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.sha256sum_value,
+        i.sha256sum_size,
+        i.sha256sum_null);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    sqlite::statement_kind sk (sqlite::statement_select);
+    {
+      if (composite_value_traits< ::bpkg::available_package_id, id_sqlite >::init (
+            i.id_value,
+            id,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::persist_statement[] =
+  "INSERT INTO \"main\".\"available_package\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"version_upstream\", "
+  "\"version_release\", "
+  "\"upstream_version\", "
+  "\"type\", "
+  "\"project\", "
+  "\"alt_naming\", "
+  "\"bootstrap_build\", "
+  "\"root_build\", "
+  "\"sha256sum\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::find_statement[] =
+  "SELECT "
+  "\"main\".\"available_package\".\"name\", "
+  "\"main\".\"available_package\".\"version_epoch\", "
+  "\"main\".\"available_package\".\"version_canonical_upstream\", "
+  "\"main\".\"available_package\".\"version_canonical_release\", "
+  "\"main\".\"available_package\".\"version_revision\", "
+  "\"main\".\"available_package\".\"version_iteration\", "
+  "\"main\".\"available_package\".\"version_upstream\", "
+  "\"main\".\"available_package\".\"version_release\", "
+  "\"main\".\"available_package\".\"upstream_version\", "
+  "\"main\".\"available_package\".\"type\", "
+  "\"main\".\"available_package\".\"project\", "
+  "\"main\".\"available_package\".\"alt_naming\", "
+  "\"main\".\"available_package\".\"bootstrap_build\", "
+  "\"main\".\"available_package\".\"root_build\", "
+  "\"main\".\"available_package\".\"sha256sum\" "
+  "FROM \"main\".\"available_package\" "
+  "WHERE \"main\".\"available_package\".\"name\"=? AND \"main\".\"available_package\".\"version_epoch\"=? AND \"main\".\"available_package\".\"version_canonical_upstream\"=? AND \"main\".\"available_package\".\"version_canonical_release\"=? AND \"main\".\"available_package\".\"version_revision\"=? AND \"main\".\"available_package\".\"version_iteration\"=?";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::update_statement[] =
+  "UPDATE \"main\".\"available_package\" "
+  "SET "
+  "\"version_upstream\"=?, "
+  "\"version_release\"=?, "
+  "\"upstream_version\"=?, "
+  "\"type\"=?, "
+  "\"project\"=?, "
+  "\"alt_naming\"=?, "
+  "\"bootstrap_build\"=?, "
+  "\"root_build\"=?, "
+  "\"sha256sum\"=? "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::erase_statement[] =
+  "DELETE FROM \"main\".\"available_package\" "
+  "WHERE \"name\"=? AND \"version_epoch\"=? AND \"version_canonical_upstream\"=? AND \"version_canonical_release\"=? AND \"version_revision\"=? AND \"version_iteration\"=?";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::query_statement[] =
+  "SELECT "
+  "\"main\".\"available_package\".\"name\", "
+  "\"main\".\"available_package\".\"version_epoch\", "
+  "\"main\".\"available_package\".\"version_canonical_upstream\", "
+  "\"main\".\"available_package\".\"version_canonical_release\", "
+  "\"main\".\"available_package\".\"version_revision\", "
+  "\"main\".\"available_package\".\"version_iteration\", "
+  "\"main\".\"available_package\".\"version_upstream\", "
+  "\"main\".\"available_package\".\"version_release\", "
+  "\"main\".\"available_package\".\"upstream_version\", "
+  "\"main\".\"available_package\".\"type\", "
+  "\"main\".\"available_package\".\"project\", "
+  "\"main\".\"available_package\".\"alt_naming\", "
+  "\"main\".\"available_package\".\"bootstrap_build\", "
+  "\"main\".\"available_package\".\"root_build\", "
+  "\"main\".\"available_package\".\"sha256sum\" "
+  "FROM \"main\".\"available_package\"";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::erase_query_statement[] =
+  "DELETE FROM \"main\".\"available_package\"";
+
+  const char access::object_traits_impl< ::bpkg::available_package, id_sqlite >::table_name[] =
+  "\"main\".\"available_package\"";
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  persist (database& db, const object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // languages
+    //
+    {
+      ::butl::small_vector< ::bpkg::language, 1 > const& v =
+        obj.languages;
+
+      languages_traits::persist (
+        v,
+        esc.languages);
+    }
+
+    // locations
+    //
+    {
+      ::butl::small_vector< ::bpkg::package_location, 1 > const& v =
+        obj.locations;
+
+      locations_traits::persist (
+        v,
+        esc.locations);
+    }
+
+    // dependencies
+    //
+    {
+      ::bpkg::available_package::dependencies_type const& v =
+        obj.dependencies;
+
+      dependencies_traits::persist (
+        v,
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      // From package.hxx:868:7
+      ::std::map< ::odb::nested_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency_alternative > const& v =
+        odb::nested_get (obj.dependencies);
+
+      dependency_alternatives_traits::persist (
+        v,
+        esc.dependency_alternatives);
+    }
+
+    // dependency_alternative_dependencies
+    //
+    {
+      // From package.hxx:886:7
+      ::std::map< ::odb::nested2_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency > const& v =
+        odb::nested2_get (obj.dependencies);
+
+      dependency_alternative_dependencies_traits::persist (
+        v,
+        esc.dependency_alternative_dependencies);
+    }
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::bpkg::test_dependency, 1 > const& v =
+        obj.tests;
+
+      tests_traits::persist (
+        v,
+        esc.tests);
+    }
+
+    // buildfiles
+    //
+    {
+      ::std::vector< ::bpkg::buildfile > const& v =
+        obj.buildfiles;
+
+      buildfiles_traits::persist (
+        v,
+        esc.buildfiles);
+    }
+
+    // distribution_values
+    //
+    {
+      ::std::vector< ::bpkg::distribution_name_value > const& v =
+        obj.distribution_values;
+
+      distribution_values_traits::persist (
+        v,
+        esc.distribution_values);
+    }
+
+    obj.languages_section.reset (true, false);
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace sqlite;
+    using sqlite::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    sqlite::connection& conn (tr.connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // locations
+    //
+    {
+      ::butl::small_vector< ::bpkg::package_location, 1 > const& v =
+        obj.locations;
+
+      locations_traits::update (
+        v,
+        esc.locations);
+    }
+
+    // dependencies
+    //
+    {
+      ::bpkg::available_package::dependencies_type const& v =
+        obj.dependencies;
+
+      dependencies_traits::update (
+        v,
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      // From package.hxx:868:7
+      ::std::map< ::odb::nested_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency_alternative > const& v =
+        odb::nested_get (obj.dependencies);
+
+      dependency_alternatives_traits::update (
+        v,
+        esc.dependency_alternatives);
+    }
+
+    // dependency_alternative_dependencies
+    //
+    {
+      // From package.hxx:886:7
+      ::std::map< ::odb::nested2_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency > const& v =
+        odb::nested2_get (obj.dependencies);
+
+      dependency_alternative_dependencies_traits::update (
+        v,
+        esc.dependency_alternative_dependencies);
+    }
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::bpkg::test_dependency, 1 > const& v =
+        obj.tests;
+
+      tests_traits::update (
+        v,
+        esc.tests);
+    }
+
+    // buildfiles
+    //
+    {
+      ::std::vector< ::bpkg::buildfile > const& v =
+        obj.buildfiles;
+
+      buildfiles_traits::update (
+        v,
+        esc.buildfiles);
+    }
+
+    // distribution_values
+    //
+    {
+      ::std::vector< ::bpkg::distribution_name_value > const& v =
+        obj.distribution_values;
+
+      distribution_values_traits::update (
+        v,
+        esc.distribution_values);
+    }
+
+    if (obj.languages_section.loaded ())
+    {
+      languages_section_traits::update (esc, obj);
+    }
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // languages
+    //
+    {
+      languages_traits::erase (
+        esc.languages);
+    }
+
+    // locations
+    //
+    {
+      locations_traits::erase (
+        esc.locations);
+    }
+
+    // dependencies
+    //
+    {
+      dependencies_traits::erase (
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      dependency_alternatives_traits::erase (
+        esc.dependency_alternatives);
+    }
+
+    // dependency_alternative_dependencies
+    //
+    {
+      dependency_alternative_dependencies_traits::erase (
+        esc.dependency_alternative_dependencies);
+    }
+
+    // tests
+    //
+    {
+      tests_traits::erase (
+        esc.tests);
+    }
+
+    // buildfiles
+    //
+    {
+      buildfiles_traits::erase (
+        esc.buildfiles);
+    }
+
+    // distribution_values
+    //
+    {
+      distribution_values_traits::erase (
+        esc.distribution_values);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::bpkg::available_package, id_sqlite >::pointer_type
+  access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  find (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  load (connection& conn, object_type& obj, section& s)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& c (static_cast<sqlite::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    bool r (false);
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    if (!r && &s == &obj.languages_section)
+    {
+      languages_section_traits::load (esc, obj);
+      r = true;
+    }
+
+    sts.load_delayed (0);
+    l.unlock ();
+    return r;
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  update (connection& conn, const object_type& obj, const section& s)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& c (static_cast<sqlite::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (&s == &obj.languages_section)languages_section_traits::update (esc, obj);
+    else
+      return false;
+
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace sqlite;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // locations
+    //
+    {
+      ::butl::small_vector< ::bpkg::package_location, 1 >& v =
+        obj.locations;
+
+      locations_traits::load (
+        v,
+        esc.locations);
+    }
+
+    // dependencies
+    //
+    {
+      ::bpkg::available_package::dependencies_type& v =
+        obj.dependencies;
+
+      dependencies_traits::load (
+        v,
+        esc.dependencies);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      ::std::map< ::odb::nested_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency_alternative > v;
+
+      dependency_alternatives_traits::load (
+        v,
+        esc.dependency_alternatives);
+
+      // From package.hxx:869:7
+      odb::nested_set (obj.dependencies, std::move (v));
+    }
+
+    // dependency_alternative_dependencies
+    //
+    {
+      ::std::map< ::odb::nested2_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency > v;
+
+      dependency_alternative_dependencies_traits::load (
+        v,
+        esc.dependency_alternative_dependencies);
+
+      // From package.hxx:887:7
+      odb::nested2_set (obj.dependencies, std::move (v));
+    }
+
+    // tests
+    //
+    {
+      ::butl::small_vector< ::bpkg::test_dependency, 1 >& v =
+        obj.tests;
+
+      tests_traits::load (
+        v,
+        esc.tests);
+    }
+
+    // buildfiles
+    //
+    {
+      ::std::vector< ::bpkg::buildfile >& v =
+        obj.buildfiles;
+
+      buildfiles_traits::load (
+        v,
+        esc.buildfiles);
+    }
+
+    // distribution_values
+    //
+    {
+      ::std::vector< ::bpkg::distribution_name_value >& v =
+        obj.distribution_values;
+
+      distribution_values_traits::load (
+        v,
+        esc.distribution_values);
+    }
+
+    if (reload)
+    {
+      if (obj.languages_section.loaded ())
+      {
+        languages_section_traits::load (esc, obj);
+        obj.languages_section.reset (true, false);
+      }
+    }
+    else
+      obj.languages_section.reset ();
+  }
+
+  result< access::object_traits_impl< ::bpkg::available_package, id_sqlite >::object_type >
+  access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) sqlite::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  erase_query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      text,
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // available_package_count
+  //
+
+  bool access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = false;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      sqlite::value_traits<
+          ::std::size_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "count(*) ");
+
+    r += "FROM \"main\".\"available_package\"";
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // available_test
+  //
+
+  const char alias_traits<  ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::available_test, id_sqlite >::package_tag>::
+  table_name[] = "\"package\"";
+
+  bool access::view_traits_impl< ::bpkg::available_test, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // package
+    //
+    if (object_traits_impl< ::bpkg::available_package, id_sqlite >::grow (
+          i.package_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::available_test, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // package
+    //
+    object_traits_impl< ::bpkg::available_package, id_sqlite >::bind (
+      b + n, i.package_value, sk);
+    n += 15UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::available_test, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (*db));
+
+    // package pre
+    //
+    typedef ::bpkg::available_package package_object_type;
+    typedef object_traits_impl<package_object_type, id_sqlite> package_object_traits;
+    typedef package_object_traits::pointer_type package_pointer_type;
+    typedef package_object_traits::pointer_traits package_pointer_traits;
+    typedef package_object_traits::pointer_cache_traits package_cache_traits;
+
+    package_object_traits::id_type package_id;
+    package_pointer_type package_p;
+    package_pointer_traits::guard package_pg;
+    package_cache_traits::insert_guard package_ig;
+    package_object_type* package_o (0);
+
+    {
+      if (!composite_value_traits< package_object_traits::id_type, id_sqlite >::get_null (
+            i.package_value.id_value))
+      {
+        package_id = package_object_traits::id (i.package_value);
+        package_p = package_cache_traits::find (*db, package_id);
+
+        if (package_pointer_traits::null_ptr (package_p))
+        {
+          package_p = object_factory<package_object_type, package_pointer_type>::create ();
+          package_pg.reset (package_p);
+          package_ig.reset (package_cache_traits::insert (*db, package_id, package_p));
+          package_o = package_pointer_traits::get_ptr (package_p);
+        }
+      }
+    }
+
+    // package
+    //
+    {
+      if (package_o != 0)
+      {
+        package_object_traits::callback (*db, *package_o, callback_event::pre_load);
+        package_object_traits::init (*package_o, i.package_value, db);
+        package_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<package_object_type> ());
+        package_object_traits::statements_type::auto_lock l (sts);
+        assert (l.locked ()) /* Must be a top-level call. */;
+
+        package_object_traits::id_image_type& i (sts.id_image ());
+        package_object_traits::init (i, package_id);
+        sqlite::binding& idb (sts.id_image_binding ());
+        if (i.version != sts.id_image_version () || idb.version == 0)
+        {
+          package_object_traits::bind (idb.bind, i);
+          sts.id_image_version (i.version);
+          idb.version++;
+        }
+
+        package_object_traits::load_ (sts, *package_o, false);
+        sts.load_delayed (0);
+        l.unlock ();
+      }
+    }
+
+    // package post
+    //
+    {
+      if (package_o != 0)
+      {
+        package_object_traits::callback (*db, *package_o, callback_event::post_load);
+        package_cache_traits::load (package_ig.position ());
+        package_ig.release ();
+        package_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.package = ::std::shared_ptr< ::bpkg::available_package > (
+        std::move (package_p));
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::available_test, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::available_test, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"package\".\"name\", "
+      "\"package\".\"version_epoch\", "
+      "\"package\".\"version_canonical_upstream\", "
+      "\"package\".\"version_canonical_release\", "
+      "\"package\".\"version_revision\", "
+      "\"package\".\"version_iteration\", "
+      "\"package\".\"version_upstream\", "
+      "\"package\".\"version_release\", "
+      "\"package\".\"upstream_version\", "
+      "\"package\".\"type\", "
+      "\"package\".\"project\", "
+      "\"package\".\"alt_naming\", "
+      "\"package\".\"bootstrap_build\", "
+      "\"package\".\"root_build\", "
+      "\"package\".\"sha256sum\" ");
+
+    r += "FROM \"main\".\"available_package\" AS \"package\"";
+
+    r += " INNER JOIN \"main\".\"available_package_dependencies\" AS \"pd\" ON";
+    // From package.hxx:952:5
+    r += "pd.type IN ('tests', 'examples', 'benchmarks') AND pd.name = " + query_columns::id.name + "AND" + "pd.version_epoch = " + query_columns::id.version.epoch + "AND" + "pd.version_canonical_upstream = " + query_columns::id.version.canonical_upstream + "AND" + "pd.version_canonical_release = " + query_columns::id.version.canonical_release + "AND" + "pd.version_revision = " + query_columns::id.version.revision + "AND" + "pd.version_iteration = " + query_columns::id.version.iteration;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::available_test, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::available_test, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::available_test, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::available_test, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // available_main
+  //
+
+  const char alias_traits<  ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::available_main, id_sqlite >::package_tag>::
+  table_name[] = "\"package\"";
+
+  bool access::view_traits_impl< ::bpkg::available_main, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // package
+    //
+    if (object_traits_impl< ::bpkg::available_package, id_sqlite >::grow (
+          i.package_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::available_main, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // package
+    //
+    object_traits_impl< ::bpkg::available_package, id_sqlite >::bind (
+      b + n, i.package_value, sk);
+    n += 15UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::available_main, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (*db));
+
+    // package pre
+    //
+    typedef ::bpkg::available_package package_object_type;
+    typedef object_traits_impl<package_object_type, id_sqlite> package_object_traits;
+    typedef package_object_traits::pointer_type package_pointer_type;
+    typedef package_object_traits::pointer_traits package_pointer_traits;
+    typedef package_object_traits::pointer_cache_traits package_cache_traits;
+
+    package_object_traits::id_type package_id;
+    package_pointer_type package_p;
+    package_pointer_traits::guard package_pg;
+    package_cache_traits::insert_guard package_ig;
+    package_object_type* package_o (0);
+
+    {
+      if (!composite_value_traits< package_object_traits::id_type, id_sqlite >::get_null (
+            i.package_value.id_value))
+      {
+        package_id = package_object_traits::id (i.package_value);
+        package_p = package_cache_traits::find (*db, package_id);
+
+        if (package_pointer_traits::null_ptr (package_p))
+        {
+          package_p = object_factory<package_object_type, package_pointer_type>::create ();
+          package_pg.reset (package_p);
+          package_ig.reset (package_cache_traits::insert (*db, package_id, package_p));
+          package_o = package_pointer_traits::get_ptr (package_p);
+        }
+      }
+    }
+
+    // package
+    //
+    {
+      if (package_o != 0)
+      {
+        package_object_traits::callback (*db, *package_o, callback_event::pre_load);
+        package_object_traits::init (*package_o, i.package_value, db);
+        package_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<package_object_type> ());
+        package_object_traits::statements_type::auto_lock l (sts);
+        assert (l.locked ()) /* Must be a top-level call. */;
+
+        package_object_traits::id_image_type& i (sts.id_image ());
+        package_object_traits::init (i, package_id);
+        sqlite::binding& idb (sts.id_image_binding ());
+        if (i.version != sts.id_image_version () || idb.version == 0)
+        {
+          package_object_traits::bind (idb.bind, i);
+          sts.id_image_version (i.version);
+          idb.version++;
+        }
+
+        package_object_traits::load_ (sts, *package_o, false);
+        sts.load_delayed (0);
+        l.unlock ();
+      }
+    }
+
+    // package post
+    //
+    {
+      if (package_o != 0)
+      {
+        package_object_traits::callback (*db, *package_o, callback_event::post_load);
+        package_cache_traits::load (package_ig.position ());
+        package_ig.release ();
+        package_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.package = ::std::shared_ptr< ::bpkg::available_package > (
+        std::move (package_p));
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::available_main, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::available_main, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT DISTINCT "
+      "\"package\".\"name\", "
+      "\"package\".\"version_epoch\", "
+      "\"package\".\"version_canonical_upstream\", "
+      "\"package\".\"version_canonical_release\", "
+      "\"package\".\"version_revision\", "
+      "\"package\".\"version_iteration\", "
+      "\"package\".\"version_upstream\", "
+      "\"package\".\"version_release\", "
+      "\"package\".\"upstream_version\", "
+      "\"package\".\"type\", "
+      "\"package\".\"project\", "
+      "\"package\".\"alt_naming\", "
+      "\"package\".\"bootstrap_build\", "
+      "\"package\".\"root_build\", "
+      "\"package\".\"sha256sum\" ");
+
+    r += "FROM \"main\".\"available_package\" AS \"package\"";
+
+    r += " INNER JOIN \"main\".\"available_package_tests\" AS \"pt\" ON";
+    // From package.hxx:971:5
+    r += "pt.name = " + query_columns::id.name + "AND" + "pt.version_epoch = " + query_columns::id.version.epoch + "AND" + "pt.version_canonical_upstream = " + query_columns::id.version.canonical_upstream + "AND" + "pt.version_canonical_release = " + query_columns::id.version.canonical_release + "AND" + "pt.version_revision = " + query_columns::id.version.revision + "AND" + "pt.version_iteration = " + query_columns::id.version.iteration;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::available_main, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::available_main, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::available_main, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::available_main, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // prerequisite_info
+  //
+
+  bool access::composite_value_traits< ::bpkg::prerequisite_info, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // constraint
+    //
+    if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::grow (
+          i.constraint_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::prerequisite_info, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // constraint
+    //
+    composite_value_traits< ::bpkg::version_constraint, id_sqlite >::bind (
+      b + n, i.constraint_value, sk);
+    n += 16UL;
+  }
+
+  bool access::composite_value_traits< ::bpkg::prerequisite_info, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // constraint
+    //
+    {
+      ::butl::optional< ::bpkg::version_constraint > const& v =
+        o.constraint;
+
+      if (wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_null (v))
+        composite_value_traits< ::bpkg::version_constraint, id_sqlite >::set_null (
+          i.constraint_value, sk);
+      else
+      {
+        const::bpkg::version_constraint& vw = 
+          wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_ref (v);
+
+        if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::init (
+              i.constraint_value,
+              vw,
+              sk))
+          grew = true;
+      }
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::prerequisite_info, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // constraint
+    //
+    {
+      ::butl::optional< ::bpkg::version_constraint >& v =
+        o.constraint;
+
+      if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::get_null (
+            i.constraint_value))
+        wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_null (v);
+      else
+      {
+        ::bpkg::version_constraint& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::version_constraint, id_sqlite >::init (
+          vw,
+          i.constraint_value,
+          db);
+      }
+    }
+  }
+
+  // _selected_package_ref
+  //
+
+  bool access::composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // configuration
+    //
+    if (t[0UL])
+    {
+      i.configuration_value.capacity (i.configuration_size);
+      grew = true;
+    }
+
+    // prerequisite
+    //
+    if (t[1UL])
+    {
+      i.prerequisite_value.capacity (i.prerequisite_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // configuration
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.configuration_value.data ();
+    b[n].size = &i.configuration_size;
+    b[n].capacity = i.configuration_value.capacity ();
+    b[n].is_null = &i.configuration_null;
+    n++;
+
+    // prerequisite
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::package_name,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.prerequisite_value.data ();
+    b[n].size = &i.prerequisite_size;
+    b[n].capacity = i.prerequisite_value.capacity ();
+    b[n].is_null = &i.prerequisite_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // configuration
+    //
+    {
+      ::butl::uuid const& v =
+        o.configuration;
+
+      // From package.hxx:66:14
+      ::std::string const& vt =
+        (v).string ();
+
+      bool is_null (false);
+      std::size_t cap (i.configuration_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.configuration_value,
+        i.configuration_size,
+        is_null,
+        vt);
+      i.configuration_null = is_null;
+      grew = grew || (cap != i.configuration_value.capacity ());
+    }
+
+    // prerequisite
+    //
+    {
+      ::bpkg::package_name const& v =
+        o.prerequisite;
+
+      bool is_null (false);
+      std::size_t cap (i.prerequisite_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_image (
+        i.prerequisite_value,
+        i.prerequisite_size,
+        is_null,
+        v);
+      i.prerequisite_null = is_null;
+      grew = grew || (cap != i.prerequisite_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // configuration
+    //
+    {
+      ::butl::uuid& v =
+        o.configuration;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.configuration_value,
+        i.configuration_size,
+        i.configuration_null);
+
+      // From package.hxx:66:14
+      v = bpkg::uuid (vt);
+    }
+
+    // prerequisite
+    //
+    {
+      ::bpkg::package_name& v =
+        o.prerequisite;
+
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_value (
+        v,
+        i.prerequisite_value,
+        i.prerequisite_size,
+        i.prerequisite_null);
+    }
+  }
+
+  // config_variable
+  //
+
+  bool access::composite_value_traits< ::bpkg::config_variable, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // source
+    //
+    if (t[1UL])
+    {
+      i.source_value.capacity (i.source_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::config_variable, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (b);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+    ODB_POTENTIALLY_UNUSED (n);
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // source
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.source_value.data ();
+    b[n].size = &i.source_size;
+    b[n].capacity = i.source_value.capacity ();
+    b[n].is_null = &i.source_null;
+    n++;
+  }
+
+  bool access::composite_value_traits< ::bpkg::config_variable, id_sqlite >::
+  init (image_type& i,
+        const value_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    {
+      ::std::string const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // source
+    //
+    {
+      ::bpkg::config_source const& v =
+        o.source;
+
+      // From package.hxx:1151:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t cap (i.source_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.source_value,
+        i.source_size,
+        is_null,
+        vt);
+      i.source_null = is_null;
+      grew = grew || (cap != i.source_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::composite_value_traits< ::bpkg::config_variable, id_sqlite >::
+  init (value_type& o,
+        const image_type&  i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // source
+    //
+    {
+      ::bpkg::config_source& v =
+        o.source;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.source_value,
+        i.source_size,
+        i.source_null);
+
+      // From package.hxx:1151:14
+      v = bpkg::to_config_source (vt);
+    }
+  }
+
+  // selected_package
+  //
+
+  struct access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::extra_statement_cache_type
+  {
+    sqlite::container_statements_impl< prerequisites_traits > prerequisites;
+    sqlite::container_statements_impl< dependency_alternatives_traits > dependency_alternatives;
+    sqlite::container_statements_impl< config_variables_traits > config_variables;
+
+    sqlite::section_statements< ::bpkg::selected_package, dependency_alternatives_section_traits > dependency_alternatives_section;
+
+    extra_statement_cache_type (
+      sqlite::connection& c,
+      image_type& im,
+      id_image_type& idim,
+      sqlite::binding& id,
+      sqlite::binding& idv)
+    : prerequisites (c, id),
+      dependency_alternatives (c, id),
+      config_variables (c, id),
+      dependency_alternatives_section (c, im, idim, id, idv)
+    {
+    }
+  };
+
+  // prerequisites
+  //
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"selected_package_prerequisites\".\"configuration\", "
+  "\"main\".\"selected_package_prerequisites\".\"prerequisite\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_version_epoch\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_version_canonical_upstream\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_version_canonical_release\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_version_revision\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_version_iteration\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_version_upstream\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_version_release\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_version_epoch\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_version_canonical_upstream\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_version_canonical_release\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_version_revision\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_version_iteration\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_version_upstream\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_version_release\", "
+  "\"main\".\"selected_package_prerequisites\".\"min_open\", "
+  "\"main\".\"selected_package_prerequisites\".\"max_open\" "
+  "FROM \"main\".\"selected_package_prerequisites\" "
+  "WHERE \"main\".\"selected_package_prerequisites\".\"package\"=?";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"selected_package_prerequisites\" "
+  "(\"package\", "
+  "\"configuration\", "
+  "\"prerequisite\", "
+  "\"min_version_epoch\", "
+  "\"min_version_canonical_upstream\", "
+  "\"min_version_canonical_release\", "
+  "\"min_version_revision\", "
+  "\"min_version_iteration\", "
+  "\"min_version_upstream\", "
+  "\"min_version_release\", "
+  "\"max_version_epoch\", "
+  "\"max_version_canonical_upstream\", "
+  "\"max_version_canonical_release\", "
+  "\"max_version_revision\", "
+  "\"max_version_iteration\", "
+  "\"max_version_upstream\", "
+  "\"max_version_release\", "
+  "\"min_open\", "
+  "\"max_open\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"selected_package_prerequisites\" "
+  "WHERE \"package\"=?";
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // key
+    //
+    composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::bind (
+      b + n, d.key_value, sk);
+    n += 2UL;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // key
+    //
+    if (composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::grow (
+          i.key_value, t + 0UL))
+      grew = true;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 2UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  init (data_image_type& i,
+        const key_type* k,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // key
+    //
+    if (k != 0)
+    {
+      // From package.hxx:1133:14
+      ::bpkg::_selected_package_ref const& vt =
+        bpkg::_selected_package_ref (*k);
+
+      if (composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::init (
+            i.key_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  init (key_type& k,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // key
+    //
+    {
+      ::bpkg::_selected_package_ref vt;
+
+      composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::init (
+        vt,
+        i.key_value,
+        db);
+
+      // From package.hxx:1133:14
+      k = std::move (vt).to_ptr ( * db);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  insert (const key_type& k, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &k, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  select (key_type& k, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (k, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::prerequisites_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    container_traits_type::erase (fs);
+  }
+
+  // dependency_alternatives
+  //
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"selected_package_dependency_alternatives\".\"index\", "
+  "\"main\".\"selected_package_dependency_alternatives\".\"position\" "
+  "FROM \"main\".\"selected_package_dependency_alternatives\" "
+  "WHERE \"main\".\"selected_package_dependency_alternatives\".\"package\"=? ORDER BY \"main\".\"selected_package_dependency_alternatives\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"selected_package_dependency_alternatives\" "
+  "(\"package\", "
+  "\"index\", "
+  "\"position\") "
+  "VALUES "
+  "(?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"selected_package_dependency_alternatives\" "
+  "WHERE \"package\"=?";
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.value_value;
+    b[n].is_null = &d.value_null;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    t[1UL] = false;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          value_type,
+          sqlite::id_integer >::set_image (
+        i.value_value,
+        is_null,
+        v);
+      i.value_null = is_null;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      sqlite::value_traits<
+          value_type,
+          sqlite::id_integer >::set_value (
+        v,
+        i.value_value,
+        i.value_null);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // config_variables
+  //
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  select_statement[] =
+  "SELECT "
+  "\"main\".\"selected_package_config_variables\".\"index\", "
+  "\"main\".\"selected_package_config_variables\".\"name\", "
+  "\"main\".\"selected_package_config_variables\".\"source\" "
+  "FROM \"main\".\"selected_package_config_variables\" "
+  "WHERE \"main\".\"selected_package_config_variables\".\"package\"=? ORDER BY \"main\".\"selected_package_config_variables\".\"index\"";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  insert_statement[] =
+  "INSERT INTO \"main\".\"selected_package_config_variables\" "
+  "(\"package\", "
+  "\"index\", "
+  "\"name\", "
+  "\"source\") "
+  "VALUES "
+  "(?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  delete_statement[] =
+  "DELETE FROM \"main\".\"selected_package_config_variables\" "
+  "WHERE \"package\"=?";
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  bind (sqlite::bind* b,
+        const sqlite::bind* id,
+        std::size_t id_size,
+        data_image_type& d)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    size_t n (0);
+
+    // object_id
+    //
+    if (id != 0)
+      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
+    n += id_size;
+
+    // index
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &d.index_value;
+    b[n].is_null = &d.index_null;
+    n++;
+
+    // value
+    //
+    composite_value_traits< value_type, id_sqlite >::bind (
+      b + n, d.value_value, sk);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  grow (data_image_type& i,
+        bool* t)
+  {
+    bool grew (false);
+
+    // index
+    //
+    t[0UL] = false;
+
+    // value
+    //
+    if (composite_value_traits< value_type, id_sqlite >::grow (
+          i.value_value, t + 1UL))
+      grew = true;
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  init (data_image_type& i,
+        index_type* j,
+        const value_type& v)
+  {
+    using namespace sqlite;
+
+    statement_kind sk (statement_insert);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    bool grew (false);
+
+    // index
+    //
+    if (j != 0)
+    {
+      bool is_null (false);
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_image (
+        i.index_value,
+        is_null,
+        *j);
+      i.index_null = is_null;
+    }
+
+    // value
+    //
+    {
+      if (composite_value_traits< value_type, id_sqlite >::init (
+            i.value_value,
+            v,
+            sk))
+        grew = true;
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  init (index_type& j,
+        value_type& v,
+        const data_image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // index
+    //
+    {
+      sqlite::value_traits<
+          index_type,
+          sqlite::id_integer >::set_value (
+        j,
+        i.index_value,
+        i.index_null);
+    }
+
+    // value
+    //
+    {
+      composite_value_traits< value_type, id_sqlite >::init (
+        v,
+        i.value_value,
+        db);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  insert (index_type i, const value_type& v, void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (di, &i, v);
+
+    if (sts.data_binding_test_version ())
+    {
+      const binding& id (sts.id_binding ());
+      bind (sts.data_bind (), id.bind, id.count, di);
+      sts.data_binding_update_version ();
+    }
+
+    if (!sts.insert_statement ().execute ())
+      throw object_already_persistent ();
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  select (index_type& i, value_type& v, void* d)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    data_image_type& di (sts.data_image ());
+
+    init (i, v, di, &sts.connection ().database ());
+
+    select_statement& st (sts.select_statement ());
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  delete_ (void* d)
+  {
+    using namespace sqlite;
+
+    statements_type& sts (*static_cast< statements_type* > (d));
+    sts.delete_statement ().execute ();
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  persist (const container_type& c,
+           statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::persist (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  load (container_type& c,
+        statements_type& sts)
+  {
+    using namespace sqlite;
+    using sqlite::select_statement;
+
+    const binding& id (sts.id_binding ());
+
+    if (sts.data_binding_test_version ())
+    {
+      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
+      sts.data_binding_update_version ();
+    }
+
+    select_statement& st (sts.select_statement ());
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      data_image_type& di (sts.data_image ());
+      grow (di, sts.select_image_truncated ());
+
+      if (sts.data_binding_test_version ())
+      {
+        bind (sts.data_bind (), 0, id.count, di);
+        sts.data_binding_update_version ();
+        st.refetch ();
+      }
+    }
+
+    bool more (r != select_statement::no_data);
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::load (c, more, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  update (const container_type& c,
+          statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::update (c, fs);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::config_variables_traits::
+  erase (statements_type& sts)
+  {
+    using namespace sqlite;
+
+    functions_type& fs (sts.functions ());
+    fs.ordered_ = true;
+    container_traits_type::erase (fs);
+  }
+
+  // dependency_alternatives_section
+  //
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_section_traits::
+  load (extra_statement_cache_type& esc, object_type& obj)
+  {
+    // dependency_alternatives
+    //
+    {
+      ::bpkg::selected_package::indexes_type& v =
+        obj.dependency_alternatives;
+
+      dependency_alternatives_traits::load (
+        v,
+        esc.dependency_alternatives);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::dependency_alternatives_section_traits::
+  update (extra_statement_cache_type& esc, const object_type& obj)
+  {
+    // dependency_alternatives
+    //
+    {
+      ::bpkg::selected_package::indexes_type const& v =
+        obj.dependency_alternatives;
+
+      dependency_alternatives_traits::update (
+        v,
+        esc.dependency_alternatives);
+    }
+  }
+
+  access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::id_type
+  access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  id (const image_type& i)
+  {
+    sqlite::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_value (
+        id,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // version
+    //
+    if (composite_value_traits< ::bpkg::_version, id_sqlite >::grow (
+          i.version_value, t + 1UL))
+      grew = true;
+
+    // state
+    //
+    if (t[8UL])
+    {
+      i.state_value.capacity (i.state_size);
+      grew = true;
+    }
+
+    // substate
+    //
+    if (t[9UL])
+    {
+      i.substate_value.capacity (i.substate_size);
+      grew = true;
+    }
+
+    // hold_package
+    //
+    t[10UL] = false;
+
+    // hold_version
+    //
+    t[11UL] = false;
+
+    // repository_fragment
+    //
+    if (composite_value_traits< ::bpkg::_repository_location, id_sqlite >::grow (
+          i.repository_fragment_value, t + 12UL))
+      grew = true;
+
+    // archive
+    //
+    if (t[14UL])
+    {
+      i.archive_value.capacity (i.archive_size);
+      grew = true;
+    }
+
+    // purge_archive
+    //
+    t[15UL] = false;
+
+    // src_root
+    //
+    if (t[16UL])
+    {
+      i.src_root_value.capacity (i.src_root_size);
+      grew = true;
+    }
+
+    // purge_src
+    //
+    t[17UL] = false;
+
+    // manifest_checksum
+    //
+    if (t[18UL])
+    {
+      i.manifest_checksum_value.capacity (i.manifest_checksum_size);
+      grew = true;
+    }
+
+    // buildfiles_checksum
+    //
+    if (t[19UL])
+    {
+      i.buildfiles_checksum_value.capacity (i.buildfiles_checksum_size);
+      grew = true;
+    }
+
+    // out_root
+    //
+    if (t[20UL])
+    {
+      i.out_root_value.capacity (i.out_root_size);
+      grew = true;
+    }
+
+    // config_checksum
+    //
+    if (t[21UL])
+    {
+      i.config_checksum_value.capacity (i.config_checksum_size);
+      grew = true;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+
+    // name
+    //
+    if (sk != statement_update)
+    {
+      b[n].type = sqlite::image_traits<
+        ::bpkg::package_name,
+        sqlite::id_text>::bind_value;
+      b[n].buffer = i.name_value.data ();
+      b[n].size = &i.name_size;
+      b[n].capacity = i.name_value.capacity ();
+      b[n].is_null = &i.name_null;
+      n++;
+    }
+
+    // version
+    //
+    composite_value_traits< ::bpkg::_version, id_sqlite >::bind (
+      b + n, i.version_value, sk);
+    n += 7UL;
+
+    // state
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.state_value.data ();
+    b[n].size = &i.state_size;
+    b[n].capacity = i.state_value.capacity ();
+    b[n].is_null = &i.state_null;
+    n++;
+
+    // substate
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.substate_value.data ();
+    b[n].size = &i.substate_size;
+    b[n].capacity = i.substate_value.capacity ();
+    b[n].is_null = &i.substate_null;
+    n++;
+
+    // hold_package
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.hold_package_value;
+    b[n].is_null = &i.hold_package_null;
+    n++;
+
+    // hold_version
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.hold_version_value;
+    b[n].is_null = &i.hold_version_null;
+    n++;
+
+    // repository_fragment
+    //
+    composite_value_traits< ::bpkg::_repository_location, id_sqlite >::bind (
+      b + n, i.repository_fragment_value, sk);
+    n += 2UL;
+
+    // archive
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::optional_string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.archive_value.data ();
+    b[n].size = &i.archive_size;
+    b[n].capacity = i.archive_value.capacity ();
+    b[n].is_null = &i.archive_null;
+    n++;
+
+    // purge_archive
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.purge_archive_value;
+    b[n].is_null = &i.purge_archive_null;
+    n++;
+
+    // src_root
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::optional_string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.src_root_value.data ();
+    b[n].size = &i.src_root_size;
+    b[n].capacity = i.src_root_value.capacity ();
+    b[n].is_null = &i.src_root_null;
+    n++;
+
+    // purge_src
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.purge_src_value;
+    b[n].is_null = &i.purge_src_null;
+    n++;
+
+    // manifest_checksum
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.manifest_checksum_value.data ();
+    b[n].size = &i.manifest_checksum_size;
+    b[n].capacity = i.manifest_checksum_value.capacity ();
+    b[n].is_null = &i.manifest_checksum_null;
+    n++;
+
+    // buildfiles_checksum
+    //
+    b[n].type = sqlite::image_traits<
+      ::butl::optional< ::std::basic_string< char > >,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.buildfiles_checksum_value.data ();
+    b[n].size = &i.buildfiles_checksum_size;
+    b[n].capacity = i.buildfiles_checksum_value.capacity ();
+    b[n].is_null = &i.buildfiles_checksum_null;
+    n++;
+
+    // out_root
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::optional_string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.out_root_value.data ();
+    b[n].size = &i.out_root_size;
+    b[n].capacity = i.out_root_value.capacity ();
+    b[n].is_null = &i.out_root_null;
+    n++;
+
+    // config_checksum
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.config_checksum_value.data ();
+    b[n].size = &i.config_checksum_size;
+    b[n].capacity = i.config_checksum_value.capacity ();
+    b[n].is_null = &i.config_checksum_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  bind (sqlite::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    b[n].type = sqlite::image_traits<
+      ::bpkg::package_name,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.id_value.data ();
+    b[n].size = &i.id_size;
+    b[n].capacity = i.id_value.capacity ();
+    b[n].is_null = &i.id_null;
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  init (image_type& i,
+        const object_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // name
+    //
+    if (sk == statement_insert)
+    {
+      ::bpkg::package_name const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // version
+    //
+    {
+      ::bpkg::selected_package::version_type const& v =
+        o.version;
+
+      // From package.hxx:308:14
+      ::bpkg::_version const& vt =
+        bpkg::_version 
+      {
+         (v).epoch, (v).canonical_upstream, (v).canonical_release, (v).revision, (v).iteration, (v).upstream, (v).release 
+      };
+
+
+      if (composite_value_traits< ::bpkg::_version, id_sqlite >::init (
+            i.version_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    // state
+    //
+    {
+      ::bpkg::package_state const& v =
+        o.state;
+
+      // From package.hxx:1018:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t cap (i.state_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.state_value,
+        i.state_size,
+        is_null,
+        vt);
+      i.state_null = is_null;
+      grew = grew || (cap != i.state_value.capacity ());
+    }
+
+    // substate
+    //
+    {
+      ::bpkg::package_substate const& v =
+        o.substate;
+
+      // From package.hxx:1039:14
+      ::std::string const& vt =
+        to_string (v);
+
+      bool is_null (false);
+      std::size_t cap (i.substate_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.substate_value,
+        i.substate_size,
+        is_null,
+        vt);
+      i.substate_null = is_null;
+      grew = grew || (cap != i.substate_value.capacity ());
+    }
+
+    // hold_package
+    //
+    {
+      bool const& v =
+        o.hold_package;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.hold_package_value,
+        is_null,
+        v);
+      i.hold_package_null = is_null;
+    }
+
+    // hold_version
+    //
+    {
+      bool const& v =
+        o.hold_version;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.hold_version_value,
+        is_null,
+        v);
+      i.hold_version_null = is_null;
+    }
+
+    // repository_fragment
+    //
+    {
+      ::bpkg::repository_location const& v =
+        o.repository_fragment;
+
+      // From package.hxx:368:14
+      ::bpkg::_repository_location const& vt =
+        bpkg::_repository_location 
+      {
+         (v).url (), (v).empty () ? bpkg::repository_type::pkg : (v).type () 
+      };
+
+
+      if (composite_value_traits< ::bpkg::_repository_location, id_sqlite >::init (
+            i.repository_fragment_value,
+            vt,
+            sk))
+        grew = true;
+    }
+
+    // archive
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::any_path_kind< char > > > const& v =
+        o.archive;
+
+      // From package.hxx:53:14
+      ::bpkg::optional_string const& vt =
+        (v) ? (v)->string () : bpkg::optional_string ();
+
+      bool is_null (true);
+      std::size_t cap (i.archive_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_image (
+        i.archive_value,
+        i.archive_size,
+        is_null,
+        vt);
+      i.archive_null = is_null;
+      grew = grew || (cap != i.archive_value.capacity ());
+    }
+
+    // purge_archive
+    //
+    {
+      bool const& v =
+        o.purge_archive;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.purge_archive_value,
+        is_null,
+        v);
+      i.purge_archive_null = is_null;
+    }
+
+    // src_root
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::dir_path_kind< char > > > const& v =
+        o.src_root;
+
+      // From package.hxx:60:14
+      ::bpkg::optional_string const& vt =
+        (v) ? (v)->string () : bpkg::optional_string ();
+
+      bool is_null (true);
+      std::size_t cap (i.src_root_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_image (
+        i.src_root_value,
+        i.src_root_size,
+        is_null,
+        vt);
+      i.src_root_null = is_null;
+      grew = grew || (cap != i.src_root_value.capacity ());
+    }
+
+    // purge_src
+    //
+    {
+      bool const& v =
+        o.purge_src;
+
+      bool is_null (false);
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_image (
+        i.purge_src_value,
+        is_null,
+        v);
+      i.purge_src_null = is_null;
+    }
+
+    // manifest_checksum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.manifest_checksum;
+
+      bool is_null (true);
+      std::size_t cap (i.manifest_checksum_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.manifest_checksum_value,
+        i.manifest_checksum_size,
+        is_null,
+        v);
+      i.manifest_checksum_null = is_null;
+      grew = grew || (cap != i.manifest_checksum_value.capacity ());
+    }
+
+    // buildfiles_checksum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > > const& v =
+        o.buildfiles_checksum;
+
+      bool is_null (true);
+      std::size_t cap (i.buildfiles_checksum_value.capacity ());
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_image (
+        i.buildfiles_checksum_value,
+        i.buildfiles_checksum_size,
+        is_null,
+        v);
+      i.buildfiles_checksum_null = is_null;
+      grew = grew || (cap != i.buildfiles_checksum_value.capacity ());
+    }
+
+    // out_root
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::dir_path_kind< char > > > const& v =
+        o.out_root;
+
+      // From package.hxx:60:14
+      ::bpkg::optional_string const& vt =
+        (v) ? (v)->string () : bpkg::optional_string ();
+
+      bool is_null (true);
+      std::size_t cap (i.out_root_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_image (
+        i.out_root_value,
+        i.out_root_size,
+        is_null,
+        vt);
+      i.out_root_null = is_null;
+      grew = grew || (cap != i.out_root_value.capacity ());
+    }
+
+    // config_checksum
+    //
+    {
+      ::std::string const& v =
+        o.config_checksum;
+
+      bool is_null (false);
+      std::size_t cap (i.config_checksum_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.config_checksum_value,
+        i.config_checksum_size,
+        is_null,
+        v);
+      i.config_checksum_null = is_null;
+      grew = grew || (cap != i.config_checksum_value.capacity ());
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::bpkg::package_name& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // version
+    //
+    {
+      ::bpkg::selected_package::version_type& v =
+        o.version;
+
+      ::bpkg::_version vt;
+
+      composite_value_traits< ::bpkg::_version, id_sqlite >::init (
+        vt,
+        i.version_value,
+        db);
+
+      // From package.hxx:308:14
+      v = bpkg::version ((vt).epoch, std::move ((vt).upstream), std::move ((vt).release), (vt).revision, (vt).iteration);
+    }
+
+    // state
+    //
+    {
+      ::bpkg::package_state& v =
+        o.state;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.state_value,
+        i.state_size,
+        i.state_null);
+
+      // From package.hxx:1018:14
+      v = bpkg::to_package_state (vt);
+    }
+
+    // substate
+    //
+    {
+      ::bpkg::package_substate& v =
+        o.substate;
+
+      ::std::string vt;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.substate_value,
+        i.substate_size,
+        i.substate_null);
+
+      // From package.hxx:1039:14
+      v = bpkg::to_package_substate (vt);
+    }
+
+    // hold_package
+    //
+    {
+      bool& v =
+        o.hold_package;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.hold_package_value,
+        i.hold_package_null);
+    }
+
+    // hold_version
+    //
+    {
+      bool& v =
+        o.hold_version;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.hold_version_value,
+        i.hold_version_null);
+    }
+
+    // repository_fragment
+    //
+    {
+      ::bpkg::repository_location& v =
+        o.repository_fragment;
+
+      ::bpkg::_repository_location vt;
+
+      composite_value_traits< ::bpkg::_repository_location, id_sqlite >::init (
+        vt,
+        i.repository_fragment_value,
+        db);
+
+      // From package.hxx:368:14
+      v = bpkg::repository_location (std::move ((vt).url), (vt).type);
+    }
+
+    // archive
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::any_path_kind< char > > >& v =
+        o.archive;
+
+      ::bpkg::optional_string vt;
+
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.archive_value,
+        i.archive_size,
+        i.archive_null);
+
+      // From package.hxx:53:14
+      v = (vt) ? bpkg::path ( * (vt)) : bpkg::optional_path ();
+    }
+
+    // purge_archive
+    //
+    {
+      bool& v =
+        o.purge_archive;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.purge_archive_value,
+        i.purge_archive_null);
+    }
+
+    // src_root
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::dir_path_kind< char > > >& v =
+        o.src_root;
+
+      ::bpkg::optional_string vt;
+
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.src_root_value,
+        i.src_root_size,
+        i.src_root_null);
+
+      // From package.hxx:60:14
+      v = (vt) ? bpkg::dir_path ( * (vt)) : bpkg::optional_dir_path ();
+    }
+
+    // purge_src
+    //
+    {
+      bool& v =
+        o.purge_src;
+
+      sqlite::value_traits<
+          bool,
+          sqlite::id_integer >::set_value (
+        v,
+        i.purge_src_value,
+        i.purge_src_null);
+    }
+
+    // manifest_checksum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.manifest_checksum;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.manifest_checksum_value,
+        i.manifest_checksum_size,
+        i.manifest_checksum_null);
+    }
+
+    // buildfiles_checksum
+    //
+    {
+      ::butl::optional< ::std::basic_string< char > >& v =
+        o.buildfiles_checksum;
+
+      sqlite::value_traits<
+          ::butl::optional< ::std::basic_string< char > >,
+          sqlite::id_text >::set_value (
+        v,
+        i.buildfiles_checksum_value,
+        i.buildfiles_checksum_size,
+        i.buildfiles_checksum_null);
+    }
+
+    // out_root
+    //
+    {
+      ::butl::optional< ::butl::basic_path< char, ::butl::dir_path_kind< char > > >& v =
+        o.out_root;
+
+      ::bpkg::optional_string vt;
+
+      sqlite::value_traits<
+          ::bpkg::optional_string,
+          sqlite::id_text >::set_value (
+        vt,
+        i.out_root_value,
+        i.out_root_size,
+        i.out_root_null);
+
+      // From package.hxx:60:14
+      v = (vt) ? bpkg::dir_path ( * (vt)) : bpkg::optional_dir_path ();
+    }
+
+    // config_checksum
+    //
+    {
+      ::std::string& v =
+        o.config_checksum;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.config_checksum_value,
+        i.config_checksum_size,
+        i.config_checksum_null);
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    {
+      bool is_null (false);
+      std::size_t cap (i.id_value.capacity ());
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_image (
+        i.id_value,
+        i.id_size,
+        is_null,
+        id);
+      i.id_null = is_null;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::persist_statement[] =
+  "INSERT INTO \"main\".\"selected_package\" "
+  "(\"name\", "
+  "\"version_epoch\", "
+  "\"version_canonical_upstream\", "
+  "\"version_canonical_release\", "
+  "\"version_revision\", "
+  "\"version_iteration\", "
+  "\"version_upstream\", "
+  "\"version_release\", "
+  "\"state\", "
+  "\"substate\", "
+  "\"hold_package\", "
+  "\"hold_version\", "
+  "\"repository_fragment_url\", "
+  "\"repository_fragment_type\", "
+  "\"archive\", "
+  "\"purge_archive\", "
+  "\"src_root\", "
+  "\"purge_src\", "
+  "\"manifest_checksum\", "
+  "\"buildfiles_checksum\", "
+  "\"out_root\", "
+  "\"config_checksum\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::find_statement[] =
+  "SELECT "
+  "\"main\".\"selected_package\".\"name\", "
+  "\"main\".\"selected_package\".\"version_epoch\", "
+  "\"main\".\"selected_package\".\"version_canonical_upstream\", "
+  "\"main\".\"selected_package\".\"version_canonical_release\", "
+  "\"main\".\"selected_package\".\"version_revision\", "
+  "\"main\".\"selected_package\".\"version_iteration\", "
+  "\"main\".\"selected_package\".\"version_upstream\", "
+  "\"main\".\"selected_package\".\"version_release\", "
+  "\"main\".\"selected_package\".\"state\", "
+  "\"main\".\"selected_package\".\"substate\", "
+  "\"main\".\"selected_package\".\"hold_package\", "
+  "\"main\".\"selected_package\".\"hold_version\", "
+  "\"main\".\"selected_package\".\"repository_fragment_url\", "
+  "\"main\".\"selected_package\".\"repository_fragment_type\", "
+  "\"main\".\"selected_package\".\"archive\", "
+  "\"main\".\"selected_package\".\"purge_archive\", "
+  "\"main\".\"selected_package\".\"src_root\", "
+  "\"main\".\"selected_package\".\"purge_src\", "
+  "\"main\".\"selected_package\".\"manifest_checksum\", "
+  "\"main\".\"selected_package\".\"buildfiles_checksum\", "
+  "\"main\".\"selected_package\".\"out_root\", "
+  "\"main\".\"selected_package\".\"config_checksum\" "
+  "FROM \"main\".\"selected_package\" "
+  "WHERE \"main\".\"selected_package\".\"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::update_statement[] =
+  "UPDATE \"main\".\"selected_package\" "
+  "SET "
+  "\"version_epoch\"=?, "
+  "\"version_canonical_upstream\"=?, "
+  "\"version_canonical_release\"=?, "
+  "\"version_revision\"=?, "
+  "\"version_iteration\"=?, "
+  "\"version_upstream\"=?, "
+  "\"version_release\"=?, "
+  "\"state\"=?, "
+  "\"substate\"=?, "
+  "\"hold_package\"=?, "
+  "\"hold_version\"=?, "
+  "\"repository_fragment_url\"=?, "
+  "\"repository_fragment_type\"=?, "
+  "\"archive\"=?, "
+  "\"purge_archive\"=?, "
+  "\"src_root\"=?, "
+  "\"purge_src\"=?, "
+  "\"manifest_checksum\"=?, "
+  "\"buildfiles_checksum\"=?, "
+  "\"out_root\"=?, "
+  "\"config_checksum\"=? "
+  "WHERE \"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::erase_statement[] =
+  "DELETE FROM \"main\".\"selected_package\" "
+  "WHERE \"name\"=?";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::query_statement[] =
+  "SELECT "
+  "\"main\".\"selected_package\".\"name\", "
+  "\"main\".\"selected_package\".\"version_epoch\", "
+  "\"main\".\"selected_package\".\"version_canonical_upstream\", "
+  "\"main\".\"selected_package\".\"version_canonical_release\", "
+  "\"main\".\"selected_package\".\"version_revision\", "
+  "\"main\".\"selected_package\".\"version_iteration\", "
+  "\"main\".\"selected_package\".\"version_upstream\", "
+  "\"main\".\"selected_package\".\"version_release\", "
+  "\"main\".\"selected_package\".\"state\", "
+  "\"main\".\"selected_package\".\"substate\", "
+  "\"main\".\"selected_package\".\"hold_package\", "
+  "\"main\".\"selected_package\".\"hold_version\", "
+  "\"main\".\"selected_package\".\"repository_fragment_url\", "
+  "\"main\".\"selected_package\".\"repository_fragment_type\", "
+  "\"main\".\"selected_package\".\"archive\", "
+  "\"main\".\"selected_package\".\"purge_archive\", "
+  "\"main\".\"selected_package\".\"src_root\", "
+  "\"main\".\"selected_package\".\"purge_src\", "
+  "\"main\".\"selected_package\".\"manifest_checksum\", "
+  "\"main\".\"selected_package\".\"buildfiles_checksum\", "
+  "\"main\".\"selected_package\".\"out_root\", "
+  "\"main\".\"selected_package\".\"config_checksum\" "
+  "FROM \"main\".\"selected_package\"";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::erase_query_statement[] =
+  "DELETE FROM \"main\".\"selected_package\"";
+
+  const char access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::table_name[] =
+  "\"main\".\"selected_package\"";
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  persist (database& db, const object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // prerequisites
+    //
+    {
+      ::bpkg::package_prerequisites const& v =
+        obj.prerequisites;
+
+      prerequisites_traits::persist (
+        v,
+        esc.prerequisites);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      ::bpkg::selected_package::indexes_type const& v =
+        obj.dependency_alternatives;
+
+      dependency_alternatives_traits::persist (
+        v,
+        esc.dependency_alternatives);
+    }
+
+    // config_variables
+    //
+    {
+      ::std::vector< ::bpkg::config_variable > const& v =
+        obj.config_variables;
+
+      config_variables_traits::persist (
+        v,
+        esc.config_variables);
+    }
+
+    obj.dependency_alternatives_section.reset (true, false);
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace sqlite;
+    using sqlite::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    sqlite::connection& conn (tr.connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // prerequisites
+    //
+    {
+      ::bpkg::package_prerequisites const& v =
+        obj.prerequisites;
+
+      prerequisites_traits::update (
+        v,
+        esc.prerequisites);
+    }
+
+    // config_variables
+    //
+    {
+      ::std::vector< ::bpkg::config_variable > const& v =
+        obj.config_variables;
+
+      config_variables_traits::update (
+        v,
+        esc.config_variables);
+    }
+
+    if (obj.dependency_alternatives_section.loaded ())
+    {
+      dependency_alternatives_section_traits::update (esc, obj);
+    }
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // prerequisites
+    //
+    {
+      prerequisites_traits::erase (
+        esc.prerequisites);
+    }
+
+    // dependency_alternatives
+    //
+    {
+      dependency_alternatives_traits::erase (
+        esc.dependency_alternatives);
+    }
+
+    // config_variables
+    //
+    {
+      config_variables_traits::erase (
+        esc.config_variables);
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::pointer_type
+  access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  find (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  load (connection& conn, object_type& obj, section& s)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& c (static_cast<sqlite::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    bool r (false);
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    if (!r && &s == &obj.dependency_alternatives_section)
+    {
+      dependency_alternatives_section_traits::load (esc, obj);
+      r = true;
+    }
+
+    sts.load_delayed (0);
+    l.unlock ();
+    return r;
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  update (connection& conn, const object_type& obj, const section& s)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& c (static_cast<sqlite::connection&> (conn));
+    statements_type& sts (c.statement_cache ().find_object<object_type> ());
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id (obj));
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (&s == &obj.dependency_alternatives_section)dependency_alternatives_section_traits::update (esc, obj);
+    else
+      return false;
+
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace sqlite;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool reload)
+  {
+    ODB_POTENTIALLY_UNUSED (reload);
+
+    extra_statement_cache_type& esc (sts.extra_statement_cache ());
+
+    // prerequisites
+    //
+    {
+      ::bpkg::package_prerequisites& v =
+        obj.prerequisites;
+
+      prerequisites_traits::load (
+        v,
+        esc.prerequisites);
+    }
+
+    // config_variables
+    //
+    {
+      ::std::vector< ::bpkg::config_variable >& v =
+        obj.config_variables;
+
+      config_variables_traits::load (
+        v,
+        esc.config_variables);
+    }
+
+    if (reload)
+    {
+      if (obj.dependency_alternatives_section.loaded ())
+      {
+        dependency_alternatives_section_traits::load (esc, obj);
+        obj.dependency_alternatives_section.reset (true, false);
+      }
+    }
+    else
+      obj.dependency_alternatives_section.reset ();
+  }
+
+  result< access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::object_type >
+  access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) sqlite::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  erase_query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      text,
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // certificate
+  //
+
+  struct access::object_traits_impl< ::bpkg::certificate, id_sqlite >::extra_statement_cache_type
+  {
+    extra_statement_cache_type (
+      sqlite::connection&,
+      image_type&,
+      id_image_type&,
+      sqlite::binding&,
+      sqlite::binding&)
+    {
+    }
+  };
+
+  access::object_traits_impl< ::bpkg::certificate, id_sqlite >::id_type
+  access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  id (const image_type& i)
+  {
+    sqlite::database* db (0);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    id_type id;
+    {
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        id,
+        i.id_value,
+        i.id_size,
+        i.id_null);
+    }
+
+    return id;
+  }
+
+  bool access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // id
+    //
+    if (t[0UL])
+    {
+      i.id_value.capacity (i.id_size);
+      grew = true;
+    }
+
+    // fingerprint
+    //
+    if (t[1UL])
+    {
+      i.fingerprint_value.capacity (i.fingerprint_size);
+      grew = true;
+    }
+
+    // name
+    //
+    if (t[2UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // organization
+    //
+    if (t[3UL])
+    {
+      i.organization_value.capacity (i.organization_size);
+      grew = true;
+    }
+
+    // email
+    //
+    if (t[4UL])
+    {
+      i.email_value.capacity (i.email_size);
+      grew = true;
+    }
+
+    // start_date
+    //
+    t[5UL] = false;
+
+    // end_date
+    //
+    t[6UL] = false;
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    std::size_t n (0);
+
+    // id
+    //
+    if (sk != statement_update)
+    {
+      b[n].type = sqlite::image_traits<
+        ::std::string,
+        sqlite::id_text>::bind_value;
+      b[n].buffer = i.id_value.data ();
+      b[n].size = &i.id_size;
+      b[n].capacity = i.id_value.capacity ();
+      b[n].is_null = &i.id_null;
+      n++;
+    }
+
+    // fingerprint
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.fingerprint_value.data ();
+    b[n].size = &i.fingerprint_size;
+    b[n].capacity = i.fingerprint_value.capacity ();
+    b[n].is_null = &i.fingerprint_null;
+    n++;
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // organization
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.organization_value.data ();
+    b[n].size = &i.organization_size;
+    b[n].capacity = i.organization_value.capacity ();
+    b[n].is_null = &i.organization_null;
+    n++;
+
+    // email
+    //
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.email_value.data ();
+    b[n].size = &i.email_size;
+    b[n].capacity = i.email_value.capacity ();
+    b[n].is_null = &i.email_null;
+    n++;
+
+    // start_date
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.start_date_value;
+    b[n].is_null = &i.start_date_null;
+    n++;
+
+    // end_date
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.end_date_value;
+    b[n].is_null = &i.end_date_null;
+    n++;
+  }
+
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  bind (sqlite::bind* b, id_image_type& i)
+  {
+    std::size_t n (0);
+    b[n].type = sqlite::image_traits<
+      ::std::string,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.id_value.data ();
+    b[n].size = &i.id_size;
+    b[n].capacity = i.id_value.capacity ();
+    b[n].is_null = &i.id_null;
+  }
+
+  bool access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  init (image_type& i,
+        const object_type& o,
+        sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    bool grew (false);
+
+    // id
+    //
+    if (sk == statement_insert)
+    {
+      ::std::string const& v =
+        o.id;
+
+      bool is_null (false);
+      std::size_t cap (i.id_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.id_value,
+        i.id_size,
+        is_null,
+        v);
+      i.id_null = is_null;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    // fingerprint
+    //
+    {
+      ::std::string const& v =
+        o.fingerprint;
+
+      bool is_null (false);
+      std::size_t cap (i.fingerprint_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.fingerprint_value,
+        i.fingerprint_size,
+        is_null,
+        v);
+      i.fingerprint_null = is_null;
+      grew = grew || (cap != i.fingerprint_value.capacity ());
+    }
+
+    // name
+    //
+    {
+      ::std::string const& v =
+        o.name;
+
+      bool is_null (false);
+      std::size_t cap (i.name_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.name_value,
+        i.name_size,
+        is_null,
+        v);
+      i.name_null = is_null;
+      grew = grew || (cap != i.name_value.capacity ());
+    }
+
+    // organization
+    //
+    {
+      ::std::string const& v =
+        o.organization;
+
+      bool is_null (false);
+      std::size_t cap (i.organization_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.organization_value,
+        i.organization_size,
+        is_null,
+        v);
+      i.organization_null = is_null;
+      grew = grew || (cap != i.organization_value.capacity ());
+    }
+
+    // email
+    //
+    {
+      ::std::string const& v =
+        o.email;
+
+      bool is_null (false);
+      std::size_t cap (i.email_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.email_value,
+        i.email_size,
+        is_null,
+        v);
+      i.email_null = is_null;
+      grew = grew || (cap != i.email_value.capacity ());
+    }
+
+    // start_date
+    //
+    {
+      ::butl::timestamp const& v =
+        o.start_date;
+
+      // From package.hxx:84:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::uint64_t,
+          sqlite::id_integer >::set_image (
+        i.start_date_value,
+        is_null,
+        vt);
+      i.start_date_null = is_null;
+    }
+
+    // end_date
+    //
+    {
+      ::butl::timestamp const& v =
+        o.end_date;
+
+      // From package.hxx:84:14
+      ::uint64_t const& vt =
+        std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count ();
+
+      bool is_null (false);
+      sqlite::value_traits<
+          ::uint64_t,
+          sqlite::id_integer >::set_image (
+        i.end_date_value,
+        is_null,
+        vt);
+      i.end_date_null = is_null;
+    }
+
+    return grew;
+  }
+
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  init (object_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // id
+    //
+    {
+      ::std::string& v =
+        o.id;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.id_value,
+        i.id_size,
+        i.id_null);
+    }
+
+    // fingerprint
+    //
+    {
+      ::std::string& v =
+        o.fingerprint;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.fingerprint_value,
+        i.fingerprint_size,
+        i.fingerprint_null);
+    }
+
+    // name
+    //
+    {
+      ::std::string& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // organization
+    //
+    {
+      ::std::string& v =
+        o.organization;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.organization_value,
+        i.organization_size,
+        i.organization_null);
+    }
+
+    // email
+    //
+    {
+      ::std::string& v =
+        o.email;
+
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_value (
+        v,
+        i.email_value,
+        i.email_size,
+        i.email_null);
+    }
+
+    // start_date
+    //
+    {
+      ::butl::timestamp& v =
+        o.start_date;
+
+      ::uint64_t vt;
+
+      sqlite::value_traits<
+          ::uint64_t,
+          sqlite::id_integer >::set_value (
+        vt,
+        i.start_date_value,
+        i.start_date_null);
+
+      // From package.hxx:84:14
+      v = butl::timestamp (std::chrono::duration_cast < butl::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+
+    // end_date
+    //
+    {
+      ::butl::timestamp& v =
+        o.end_date;
+
+      ::uint64_t vt;
+
+      sqlite::value_traits<
+          ::uint64_t,
+          sqlite::id_integer >::set_value (
+        vt,
+        i.end_date_value,
+        i.end_date_null);
+
+      // From package.hxx:84:14
+      v = butl::timestamp (std::chrono::duration_cast < butl::timestamp::duration > (std::chrono::nanoseconds (vt)));
+    }
+  }
+
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  init (id_image_type& i, const id_type& id)
+  {
+    bool grew (false);
+    {
+      bool is_null (false);
+      std::size_t cap (i.id_value.capacity ());
+      sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::set_image (
+        i.id_value,
+        i.id_size,
+        is_null,
+        id);
+      i.id_null = is_null;
+      grew = grew || (cap != i.id_value.capacity ());
+    }
+
+    if (grew)
+      i.version++;
+  }
+
+  const char access::object_traits_impl< ::bpkg::certificate, id_sqlite >::persist_statement[] =
+  "INSERT INTO \"main\".\"certificate\" "
+  "(\"id\", "
+  "\"fingerprint\", "
+  "\"name\", "
+  "\"organization\", "
+  "\"email\", "
+  "\"start_date\", "
+  "\"end_date\") "
+  "VALUES "
+  "(?, ?, ?, ?, ?, ?, ?)";
+
+  const char access::object_traits_impl< ::bpkg::certificate, id_sqlite >::find_statement[] =
+  "SELECT "
+  "\"main\".\"certificate\".\"id\", "
+  "\"main\".\"certificate\".\"fingerprint\", "
+  "\"main\".\"certificate\".\"name\", "
+  "\"main\".\"certificate\".\"organization\", "
+  "\"main\".\"certificate\".\"email\", "
+  "\"main\".\"certificate\".\"start_date\", "
+  "\"main\".\"certificate\".\"end_date\" "
+  "FROM \"main\".\"certificate\" "
+  "WHERE \"main\".\"certificate\".\"id\"=?";
+
+  const char access::object_traits_impl< ::bpkg::certificate, id_sqlite >::update_statement[] =
+  "UPDATE \"main\".\"certificate\" "
+  "SET "
+  "\"fingerprint\"=?, "
+  "\"name\"=?, "
+  "\"organization\"=?, "
+  "\"email\"=?, "
+  "\"start_date\"=?, "
+  "\"end_date\"=? "
+  "WHERE \"id\"=?";
+
+  const char access::object_traits_impl< ::bpkg::certificate, id_sqlite >::erase_statement[] =
+  "DELETE FROM \"main\".\"certificate\" "
+  "WHERE \"id\"=?";
+
+  const char access::object_traits_impl< ::bpkg::certificate, id_sqlite >::query_statement[] =
+  "SELECT "
+  "\"main\".\"certificate\".\"id\", "
+  "\"main\".\"certificate\".\"fingerprint\", "
+  "\"main\".\"certificate\".\"name\", "
+  "\"main\".\"certificate\".\"organization\", "
+  "\"main\".\"certificate\".\"email\", "
+  "\"main\".\"certificate\".\"start_date\", "
+  "\"main\".\"certificate\".\"end_date\" "
+  "FROM \"main\".\"certificate\"";
+
+  const char access::object_traits_impl< ::bpkg::certificate, id_sqlite >::erase_query_statement[] =
+  "DELETE FROM \"main\".\"certificate\"";
+
+  const char access::object_traits_impl< ::bpkg::certificate, id_sqlite >::table_name[] =
+  "\"main\".\"certificate\"";
+
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  persist (database& db, const object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    callback (db,
+              obj,
+              callback_event::pre_persist);
+
+    image_type& im (sts.image ());
+    binding& imb (sts.insert_image_binding ());
+
+    if (init (im, obj, statement_insert))
+      im.version++;
+
+    if (im.version != sts.insert_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_insert);
+      sts.insert_image_version (im.version);
+      imb.version++;
+    }
+
+    insert_statement& st (sts.persist_statement ());
+    if (!st.execute ())
+      throw object_already_persistent ();
+
+    callback (db,
+              obj,
+              callback_event::post_persist);
+  }
+
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  update (database& db, const object_type& obj)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+
+    using namespace sqlite;
+    using sqlite::update_statement;
+
+    callback (db, obj, callback_event::pre_update);
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    sqlite::connection& conn (tr.connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& idi (sts.id_image ());
+    init (idi, id (obj));
+
+    image_type& im (sts.image ());
+    if (init (im, obj, statement_update))
+      im.version++;
+
+    bool u (false);
+    binding& imb (sts.update_image_binding ());
+    if (im.version != sts.update_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_update);
+      sts.update_image_version (im.version);
+      imb.version++;
+      u = true;
+    }
+
+    binding& idb (sts.id_image_binding ());
+    if (idi.version != sts.update_id_image_version () ||
+        idb.version == 0)
+    {
+      if (idi.version != sts.id_image_version () ||
+          idb.version == 0)
+      {
+        bind (idb.bind, idi);
+        sts.id_image_version (idi.version);
+        idb.version++;
+      }
+
+      sts.update_id_image_version (idi.version);
+
+      if (!u)
+        imb.version++;
+    }
+
+    update_statement& st (sts.update_statement ());
+    if (st.execute () == 0)
+      throw object_not_persistent ();
+
+    callback (db, obj, callback_event::post_update);
+    pointer_cache_traits::update (db, obj);
+  }
+
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  erase (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    id_image_type& i (sts.id_image ());
+    init (i, id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    if (sts.erase_statement ().execute () != 1)
+      throw object_not_persistent ();
+
+    pointer_cache_traits::erase (db, id);
+  }
+
+  access::object_traits_impl< ::bpkg::certificate, id_sqlite >::pointer_type
+  access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  find (database& db, const id_type& id)
+  {
+    using namespace sqlite;
+
+    {
+      pointer_type p (pointer_cache_traits::find (db, id));
+
+      if (!pointer_traits::null_ptr (p))
+        return p;
+    }
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+
+    if (l.locked ())
+    {
+      if (!find_ (sts, &id))
+        return pointer_type ();
+    }
+
+    pointer_type p (
+      access::object_factory<object_type, pointer_type>::create ());
+    pointer_traits::guard pg (p);
+
+    pointer_cache_traits::insert_guard ig (
+      pointer_cache_traits::insert (db, id, p));
+
+    object_type& obj (pointer_traits::get_ref (p));
+
+    if (l.locked ())
+    {
+      select_statement& st (sts.find_statement ());
+      ODB_POTENTIALLY_UNUSED (st);
+
+      callback (db, obj, callback_event::pre_load);
+      init (obj, sts.image (), &db);
+      load_ (sts, obj, false);
+      sts.load_delayed (0);
+      l.unlock ();
+      callback (db, obj, callback_event::post_load);
+      pointer_cache_traits::load (ig.position ());
+    }
+    else
+      sts.delay_load (id, obj, ig.position ());
+
+    ig.release ();
+    pg.release ();
+    return p;
+  }
+
+  bool access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  find (database& db, const id_type& id, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    reference_cache_traits::position_type pos (
+      reference_cache_traits::insert (db, id, obj));
+    reference_cache_traits::insert_guard ig (pos);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, false);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    reference_cache_traits::load (pos);
+    ig.release ();
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  reload (database& db, object_type& obj)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    statements_type::auto_lock l (sts);
+    assert (l.locked ()) /* Must be a top-level call. */;
+
+    const id_type& id (object_traits_impl::id (obj));
+    if (!find_ (sts, &id))
+      return false;
+
+    select_statement& st (sts.find_statement ());
+    ODB_POTENTIALLY_UNUSED (st);
+
+    callback (db, obj, callback_event::pre_load);
+    init (obj, sts.image (), &db);
+    load_ (sts, obj, true);
+    sts.load_delayed (0);
+    l.unlock ();
+    callback (db, obj, callback_event::post_load);
+    return true;
+  }
+
+  bool access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  find_ (statements_type& sts,
+         const id_type* id)
+  {
+    using namespace sqlite;
+
+    id_image_type& i (sts.id_image ());
+    init (i, *id);
+
+    binding& idb (sts.id_image_binding ());
+    if (i.version != sts.id_image_version () || idb.version == 0)
+    {
+      bind (idb.bind, i);
+      sts.id_image_version (i.version);
+      idb.version++;
+    }
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    select_statement& st (sts.find_statement ());
+
+    st.execute ();
+    auto_result ar (st);
+    select_statement::result r (st.fetch ());
+
+    if (r == select_statement::truncated)
+    {
+      if (grow (im, sts.select_image_truncated ()))
+        im.version++;
+
+      if (im.version != sts.select_image_version ())
+      {
+        bind (imb.bind, im, statement_select);
+        sts.select_image_version (im.version);
+        imb.version++;
+        st.refetch ();
+      }
+    }
+
+    return r != select_statement::no_data;
+  }
+
+  result< access::object_traits_impl< ::bpkg::certificate, id_sqlite >::object_type >
+  access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        q.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::object_result_impl<object_type> > r (
+      new (shared) sqlite::object_result_impl<object_type> (
+        q, st, sts, 0));
+
+    return result<object_type> (r);
+  }
+
+  unsigned long long access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  erase_query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+
+    std::string text (erase_query_statement);
+    if (!q.empty ())
+    {
+      text += ' ';
+      text += q.clause ();
+    }
+
+    q.init_parameters ();
+    delete_statement st (
+      conn,
+      text,
+      q.parameters_binding ());
+
+    return st.execute ();
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+
+    statements_type& sts (
+      conn.statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    std::string text (query_statement);
+    if (!q.empty ())
+    {
+      text += " ";
+      text += q.clause ();
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = q;
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        text,
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_object<object_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.select_image_binding ());
+
+    if (im.version != sts.select_image_version () ||
+        imb.version == 0)
+    {
+      bind (imb.bind, im, statement_select);
+      sts.select_image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::object_result_impl<object_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // package_dependent
+  //
+
+  bool access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // name
+    //
+    if (t[0UL])
+    {
+      i.name_value.capacity (i.name_size);
+      grew = true;
+    }
+
+    // constraint
+    //
+    if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::grow (
+          i.constraint_value, t + 1UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // name
+    //
+    b[n].type = sqlite::image_traits<
+      ::bpkg::package_name,
+      sqlite::id_text>::bind_value;
+    b[n].buffer = i.name_value.data ();
+    b[n].size = &i.name_size;
+    b[n].capacity = i.name_value.capacity ();
+    b[n].is_null = &i.name_null;
+    n++;
+
+    // constraint
+    //
+    composite_value_traits< ::bpkg::version_constraint, id_sqlite >::bind (
+      b + n, i.constraint_value, sk);
+    n += 16UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // name
+    //
+    {
+      ::bpkg::package_name& v =
+        o.name;
+
+      sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::set_value (
+        v,
+        i.name_value,
+        i.name_size,
+        i.name_null);
+    }
+
+    // constraint
+    //
+    {
+      ::butl::optional< ::bpkg::version_constraint >& v =
+        o.constraint;
+
+      if (composite_value_traits< ::bpkg::version_constraint, id_sqlite >::get_null (
+            i.constraint_value))
+        wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_null (v);
+      else
+      {
+        ::bpkg::version_constraint& vw =
+          wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_ref (v);
+
+        composite_value_traits< ::bpkg::version_constraint, id_sqlite >::init (
+          vw,
+          i.constraint_value,
+          db);
+      }
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"pp\".\"package\", "
+      "\"pp\".\"min_version_epoch\", "
+      "\"pp\".\"min_version_canonical_upstream\", "
+      "\"pp\".\"min_version_canonical_release\", "
+      "\"pp\".\"min_version_revision\", "
+      "\"pp\".\"min_version_iteration\", "
+      "\"pp\".\"min_version_upstream\", "
+      "\"pp\".\"min_version_release\", "
+      "\"pp\".\"max_version_epoch\", "
+      "\"pp\".\"max_version_canonical_upstream\", "
+      "\"pp\".\"max_version_canonical_release\", "
+      "\"pp\".\"max_version_revision\", "
+      "\"pp\".\"max_version_iteration\", "
+      "\"pp\".\"max_version_upstream\", "
+      "\"pp\".\"max_version_release\", "
+      "\"pp\".\"min_open\", "
+      "\"pp\".\"max_open\" ");
+
+    r += "FROM \"main\".\"selected_package_prerequisites\" AS \"pp\"";
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // fragment_repository_count
+  //
+
+  bool access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // result
+    //
+    t[0UL] = false;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // result
+    //
+    b[n].type = sqlite::bind::integer;
+    b[n].buffer = &i.result_value;
+    b[n].is_null = &i.result_null;
+    n++;
+  }
+
+  void access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    // result
+    //
+    {
+      ::std::size_t& v =
+        o.result;
+
+      sqlite::value_traits<
+          ::std::size_t,
+          sqlite::id_integer >::set_value (
+        v,
+        i.result_value,
+        i.result_null);
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "count(*) ");
+
+    r += "FROM \"main\".\"repository_fragments\"";
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // fragment_repository
+  //
+
+  bool access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // object
+    //
+    if (object_traits_impl< ::bpkg::repository, id_sqlite >::grow (
+          i.object_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // object
+    //
+    object_traits_impl< ::bpkg::repository, id_sqlite >::bind (
+      b + n, i.object_value, sk);
+    n += 5UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (*db));
+
+    // object pre
+    //
+    typedef ::bpkg::repository object_object_type;
+    typedef object_traits_impl<object_object_type, id_sqlite> object_object_traits;
+    typedef object_object_traits::pointer_type object_pointer_type;
+    typedef object_object_traits::pointer_traits object_pointer_traits;
+    typedef object_object_traits::pointer_cache_traits object_cache_traits;
+
+    object_object_traits::id_type object_id;
+    object_pointer_type object_p;
+    object_pointer_traits::guard object_pg;
+    object_cache_traits::insert_guard object_ig;
+    object_object_type* object_o (0);
+
+    {
+      if (!(i.object_value.name_null))
+      {
+        object_id = object_object_traits::id (i.object_value);
+        object_p = object_cache_traits::find (*db, object_id);
+
+        if (object_pointer_traits::null_ptr (object_p))
+        {
+          object_p = object_factory<object_object_type, object_pointer_type>::create ();
+          object_pg.reset (object_p);
+          object_ig.reset (object_cache_traits::insert (*db, object_id, object_p));
+          object_o = object_pointer_traits::get_ptr (object_p);
+        }
+      }
+    }
+
+    // object
+    //
+    {
+      if (object_o != 0)
+      {
+        object_object_traits::callback (*db, *object_o, callback_event::pre_load);
+        object_object_traits::init (*object_o, i.object_value, db);
+        object_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<object_object_type> ());
+        object_object_traits::statements_type::auto_lock l (sts);
+        assert (l.locked ()) /* Must be a top-level call. */;
+
+        object_object_traits::id_image_type& i (sts.id_image ());
+        object_object_traits::init (i, object_id);
+        sqlite::binding& idb (sts.id_image_binding ());
+        if (i.version != sts.id_image_version () || idb.version == 0)
+        {
+          object_object_traits::bind (idb.bind, i);
+          sts.id_image_version (i.version);
+          idb.version++;
+        }
+
+        object_object_traits::load_ (sts, *object_o, false);
+        sts.load_delayed (0);
+        l.unlock ();
+      }
+    }
+
+    // object post
+    //
+    {
+      if (object_o != 0)
+      {
+        object_object_traits::callback (*db, *object_o, callback_event::post_load);
+        object_cache_traits::load (object_ig.position ());
+        object_ig.release ();
+        object_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.object = ::std::shared_ptr< ::bpkg::repository > (
+        std::move (object_p));
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"main\".\"repository\".\"name\", "
+      "\"main\".\"repository\".\"url\", "
+      "\"main\".\"repository\".\"type\", "
+      "\"main\".\"repository\".\"certificate\", "
+      "\"main\".\"repository\".\"local\" ");
+
+    r += "FROM \"main\".\"repository\"";
+
+    r += " INNER JOIN \"main\".\"repository_fragments\" AS \"rfs\" ON";
+    // From package.hxx:1731:5
+    r += "rfs.repository = " + query_columns::repository::name;
+
+    r += " INNER JOIN \"main\".\"repository_fragment\" ON";
+    // From package.hxx:1733:5
+    r += "rfs.fragment = " + query_columns::repository_fragment::name;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // repository_complement_dependent
+  //
+
+  const char alias_traits<  ::bpkg::repository,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::complement_tag>::
+  table_name[] = "\"complement\"";
+
+  bool access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // object
+    //
+    if (object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::grow (
+          i.object_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // object
+    //
+    object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::bind (
+      b + n, i.object_value, sk);
+    n += 3UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (*db));
+
+    // object pre
+    //
+    typedef ::bpkg::repository_fragment object_object_type;
+    typedef object_traits_impl<object_object_type, id_sqlite> object_object_traits;
+    typedef object_object_traits::pointer_type object_pointer_type;
+    typedef object_object_traits::pointer_traits object_pointer_traits;
+    typedef object_object_traits::pointer_cache_traits object_cache_traits;
+
+    object_object_traits::id_type object_id;
+    object_pointer_type object_p;
+    object_pointer_traits::guard object_pg;
+    object_cache_traits::insert_guard object_ig;
+    object_object_type* object_o (0);
+
+    {
+      if (!(i.object_value.name_null))
+      {
+        object_id = object_object_traits::id (i.object_value);
+        object_p = object_cache_traits::find (*db, object_id);
+
+        if (object_pointer_traits::null_ptr (object_p))
+        {
+          object_p = object_factory<object_object_type, object_pointer_type>::create ();
+          object_pg.reset (object_p);
+          object_ig.reset (object_cache_traits::insert (*db, object_id, object_p));
+          object_o = object_pointer_traits::get_ptr (object_p);
+        }
+      }
+    }
+
+    // object
+    //
+    {
+      if (object_o != 0)
+      {
+        object_object_traits::callback (*db, *object_o, callback_event::pre_load);
+        object_object_traits::init (*object_o, i.object_value, db);
+        object_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<object_object_type> ());
+        object_object_traits::statements_type::auto_lock l (sts);
+        assert (l.locked ()) /* Must be a top-level call. */;
+
+        object_object_traits::id_image_type& i (sts.id_image ());
+        object_object_traits::init (i, object_id);
+        sqlite::binding& idb (sts.id_image_binding ());
+        if (i.version != sts.id_image_version () || idb.version == 0)
+        {
+          object_object_traits::bind (idb.bind, i);
+          sts.id_image_version (i.version);
+          idb.version++;
+        }
+
+        object_object_traits::load_ (sts, *object_o, false);
+        sts.load_delayed (0);
+        l.unlock ();
+      }
+    }
+
+    // object post
+    //
+    {
+      if (object_o != 0)
+      {
+        object_object_traits::callback (*db, *object_o, callback_event::post_load);
+        object_cache_traits::load (object_ig.position ());
+        object_ig.release ();
+        object_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.object = ::std::shared_ptr< ::bpkg::repository_fragment > (
+        std::move (object_p));
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"main\".\"repository_fragment\".\"name\", "
+      "\"main\".\"repository_fragment\".\"url\", "
+      "\"main\".\"repository_fragment\".\"type\" ");
+
+    r += "FROM \"main\".\"repository\" AS \"complement\"";
+
+    r += " INNER JOIN \"main\".\"repository_fragment_complements\" AS \"rfc\" ON";
+    // From package.hxx:1746:5
+    r += "rfc.complement = " + query_columns::complement::name;
+
+    r += " INNER JOIN \"main\".\"repository_fragment\" ON";
+    // From package.hxx:1748:5
+    r += "rfc.repository_fragment = " + query_columns::repository_fragment::name;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // repository_prerequisite_dependent
+  //
+
+  const char alias_traits<  ::bpkg::repository,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::prerequisite_tag>::
+  table_name[] = "\"prerequisite\"";
+
+  bool access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // object
+    //
+    if (object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::grow (
+          i.object_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // object
+    //
+    object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::bind (
+      b + n, i.object_value, sk);
+    n += 3UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (*db));
+
+    // object pre
+    //
+    typedef ::bpkg::repository_fragment object_object_type;
+    typedef object_traits_impl<object_object_type, id_sqlite> object_object_traits;
+    typedef object_object_traits::pointer_type object_pointer_type;
+    typedef object_object_traits::pointer_traits object_pointer_traits;
+    typedef object_object_traits::pointer_cache_traits object_cache_traits;
+
+    object_object_traits::id_type object_id;
+    object_pointer_type object_p;
+    object_pointer_traits::guard object_pg;
+    object_cache_traits::insert_guard object_ig;
+    object_object_type* object_o (0);
+
+    {
+      if (!(i.object_value.name_null))
+      {
+        object_id = object_object_traits::id (i.object_value);
+        object_p = object_cache_traits::find (*db, object_id);
+
+        if (object_pointer_traits::null_ptr (object_p))
+        {
+          object_p = object_factory<object_object_type, object_pointer_type>::create ();
+          object_pg.reset (object_p);
+          object_ig.reset (object_cache_traits::insert (*db, object_id, object_p));
+          object_o = object_pointer_traits::get_ptr (object_p);
+        }
+      }
+    }
+
+    // object
+    //
+    {
+      if (object_o != 0)
+      {
+        object_object_traits::callback (*db, *object_o, callback_event::pre_load);
+        object_object_traits::init (*object_o, i.object_value, db);
+        object_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<object_object_type> ());
+        object_object_traits::statements_type::auto_lock l (sts);
+        assert (l.locked ()) /* Must be a top-level call. */;
+
+        object_object_traits::id_image_type& i (sts.id_image ());
+        object_object_traits::init (i, object_id);
+        sqlite::binding& idb (sts.id_image_binding ());
+        if (i.version != sts.id_image_version () || idb.version == 0)
+        {
+          object_object_traits::bind (idb.bind, i);
+          sts.id_image_version (i.version);
+          idb.version++;
+        }
+
+        object_object_traits::load_ (sts, *object_o, false);
+        sts.load_delayed (0);
+        l.unlock ();
+      }
+    }
+
+    // object post
+    //
+    {
+      if (object_o != 0)
+      {
+        object_object_traits::callback (*db, *object_o, callback_event::post_load);
+        object_cache_traits::load (object_ig.position ());
+        object_ig.release ();
+        object_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.object = ::std::shared_ptr< ::bpkg::repository_fragment > (
+        std::move (object_p));
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"main\".\"repository_fragment\".\"name\", "
+      "\"main\".\"repository_fragment\".\"url\", "
+      "\"main\".\"repository_fragment\".\"type\" ");
+
+    r += "FROM \"main\".\"repository\" AS \"prerequisite\"";
+
+    r += " INNER JOIN \"main\".\"repository_fragment_prerequisites\" AS \"rfp\" ON";
+    // From package.hxx:1761:5
+    r += "rfp.prerequisite = " + query_columns::prerequisite::name;
+
+    r += " INNER JOIN \"main\".\"repository_fragment\" ON";
+    // From package.hxx:1763:5
+    r += "rfp.repository_fragment = " + query_columns::repository_fragment::name;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // repository_fragment_package
+  //
+
+  const char alias_traits<  ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::package_tag>::
+  table_name[] = "\"package\"";
+
+  bool access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // package
+    //
+    if (object_traits_impl< ::bpkg::available_package, id_sqlite >::grow (
+          i.package_value, t + 0UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // package
+    //
+    object_traits_impl< ::bpkg::available_package, id_sqlite >::bind (
+      b + n, i.package_value, sk);
+    n += 15UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (*db));
+
+    // package pre
+    //
+    typedef ::bpkg::available_package package_object_type;
+    typedef object_traits_impl<package_object_type, id_sqlite> package_object_traits;
+    typedef package_object_traits::pointer_type package_pointer_type;
+    typedef package_object_traits::pointer_traits package_pointer_traits;
+    typedef package_object_traits::pointer_cache_traits package_cache_traits;
+
+    package_object_traits::id_type package_id;
+    package_pointer_type package_p;
+    package_pointer_traits::guard package_pg;
+    package_cache_traits::insert_guard package_ig;
+    package_object_type* package_o (0);
+
+    {
+      if (!composite_value_traits< package_object_traits::id_type, id_sqlite >::get_null (
+            i.package_value.id_value))
+      {
+        package_id = package_object_traits::id (i.package_value);
+        package_p = package_cache_traits::find (*db, package_id);
+
+        if (package_pointer_traits::null_ptr (package_p))
+        {
+          package_p = object_factory<package_object_type, package_pointer_type>::create ();
+          package_pg.reset (package_p);
+          package_ig.reset (package_cache_traits::insert (*db, package_id, package_p));
+          package_o = package_pointer_traits::get_ptr (package_p);
+        }
+      }
+    }
+
+    // package
+    //
+    {
+      if (package_o != 0)
+      {
+        package_object_traits::callback (*db, *package_o, callback_event::pre_load);
+        package_object_traits::init (*package_o, i.package_value, db);
+        package_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<package_object_type> ());
+        package_object_traits::statements_type::auto_lock l (sts);
+        assert (l.locked ()) /* Must be a top-level call. */;
+
+        package_object_traits::id_image_type& i (sts.id_image ());
+        package_object_traits::init (i, package_id);
+        sqlite::binding& idb (sts.id_image_binding ());
+        if (i.version != sts.id_image_version () || idb.version == 0)
+        {
+          package_object_traits::bind (idb.bind, i);
+          sts.id_image_version (i.version);
+          idb.version++;
+        }
+
+        package_object_traits::load_ (sts, *package_o, false);
+        sts.load_delayed (0);
+        l.unlock ();
+      }
+    }
+
+    // package post
+    //
+    {
+      if (package_o != 0)
+      {
+        package_object_traits::callback (*db, *package_o, callback_event::post_load);
+        package_cache_traits::load (package_ig.position ());
+        package_ig.release ();
+        package_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.package = ::std::shared_ptr< ::bpkg::available_package > (
+        std::move (package_p));
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"package\".\"name\", "
+      "\"package\".\"version_epoch\", "
+      "\"package\".\"version_canonical_upstream\", "
+      "\"package\".\"version_canonical_release\", "
+      "\"package\".\"version_revision\", "
+      "\"package\".\"version_iteration\", "
+      "\"package\".\"version_upstream\", "
+      "\"package\".\"version_release\", "
+      "\"package\".\"upstream_version\", "
+      "\"package\".\"type\", "
+      "\"package\".\"project\", "
+      "\"package\".\"alt_naming\", "
+      "\"package\".\"bootstrap_build\", "
+      "\"package\".\"root_build\", "
+      "\"package\".\"sha256sum\" ");
+
+    r += "FROM \"main\".\"repository_fragment\"";
+
+    r += " INNER JOIN \"main\".\"available_package_locations\" AS \"pl\" ON";
+    // From package.hxx:1775:5
+    r += "pl.repository_fragment = " + query_columns::repository_fragment::name;
+
+    r += " INNER JOIN \"main\".\"available_package\" AS \"package\" ON";
+    // From package.hxx:1777:5
+    r += "pl.name = " + query_columns::package::id.name + "AND" + "pl.version_epoch = " + query_columns::package::id.version.epoch + "AND" + "pl.version_canonical_upstream = " + query_columns::package::id.version.canonical_upstream + "AND" + "pl.version_canonical_release = " + query_columns::package::id.version.canonical_release + "AND" + "pl.version_revision = " + query_columns::package::id.version.revision + "AND" + "pl.version_iteration = " + query_columns::package::id.version.iteration;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+
+  // package_repository_fragment
+  //
+
+  const char alias_traits<  ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::package_tag>::
+  table_name[] = "\"package\"";
+
+  bool access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::
+  grow (image_type& i,
+        bool* t)
+  {
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (t);
+
+    bool grew (false);
+
+    // package_id
+    //
+    if (composite_value_traits< ::bpkg::available_package_id, id_sqlite >::grow (
+          i.package_id_value, t + 0UL))
+      grew = true;
+
+    // repository_fragment
+    //
+    if (object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::grow (
+          i.repository_fragment_value, t + 6UL))
+      grew = true;
+
+    return grew;
+  }
+
+  void access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::
+  bind (sqlite::bind* b,
+        image_type& i)
+  {
+    using namespace sqlite;
+
+    sqlite::statement_kind sk (statement_select);
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    std::size_t n (0);
+
+    // package_id
+    //
+    composite_value_traits< ::bpkg::available_package_id, id_sqlite >::bind (
+      b + n, i.package_id_value, sk);
+    n += 6UL;
+
+    // repository_fragment
+    //
+    object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::bind (
+      b + n, i.repository_fragment_value, sk);
+    n += 3UL;
+  }
+
+  void access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::
+  init (view_type& o,
+        const image_type& i,
+        database* db)
+  {
+    ODB_POTENTIALLY_UNUSED (o);
+    ODB_POTENTIALLY_UNUSED (i);
+    ODB_POTENTIALLY_UNUSED (db);
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (*db));
+
+    // repository_fragment pre
+    //
+    typedef ::bpkg::repository_fragment repository_fragment_object_type;
+    typedef object_traits_impl<repository_fragment_object_type, id_sqlite> repository_fragment_object_traits;
+    typedef repository_fragment_object_traits::pointer_type repository_fragment_pointer_type;
+    typedef repository_fragment_object_traits::pointer_traits repository_fragment_pointer_traits;
+    typedef repository_fragment_object_traits::pointer_cache_traits repository_fragment_cache_traits;
+
+    repository_fragment_object_traits::id_type repository_fragment_id;
+    repository_fragment_pointer_type repository_fragment_p;
+    repository_fragment_pointer_traits::guard repository_fragment_pg;
+    repository_fragment_cache_traits::insert_guard repository_fragment_ig;
+    repository_fragment_object_type* repository_fragment_o (0);
+
+    {
+      if (!(i.repository_fragment_value.name_null))
+      {
+        repository_fragment_id = repository_fragment_object_traits::id (i.repository_fragment_value);
+        repository_fragment_p = repository_fragment_cache_traits::find (*db, repository_fragment_id);
+
+        if (repository_fragment_pointer_traits::null_ptr (repository_fragment_p))
+        {
+          repository_fragment_p = object_factory<repository_fragment_object_type, repository_fragment_pointer_type>::create ();
+          repository_fragment_pg.reset (repository_fragment_p);
+          repository_fragment_ig.reset (repository_fragment_cache_traits::insert (*db, repository_fragment_id, repository_fragment_p));
+          repository_fragment_o = repository_fragment_pointer_traits::get_ptr (repository_fragment_p);
+        }
+      }
+    }
+
+    // package_id
+    //
+    {
+      ::bpkg::available_package_id& v =
+        o.package_id;
+
+      composite_value_traits< ::bpkg::available_package_id, id_sqlite >::init (
+        v,
+        i.package_id_value,
+        db);
+    }
+
+    // repository_fragment
+    //
+    {
+      if (repository_fragment_o != 0)
+      {
+        repository_fragment_object_traits::callback (*db, *repository_fragment_o, callback_event::pre_load);
+        repository_fragment_object_traits::init (*repository_fragment_o, i.repository_fragment_value, db);
+        repository_fragment_object_traits::statements_type& sts (
+          conn.statement_cache ().find_object<repository_fragment_object_type> ());
+        repository_fragment_object_traits::statements_type::auto_lock l (sts);
+        assert (l.locked ()) /* Must be a top-level call. */;
+
+        repository_fragment_object_traits::id_image_type& i (sts.id_image ());
+        repository_fragment_object_traits::init (i, repository_fragment_id);
+        sqlite::binding& idb (sts.id_image_binding ());
+        if (i.version != sts.id_image_version () || idb.version == 0)
+        {
+          repository_fragment_object_traits::bind (idb.bind, i);
+          sts.id_image_version (i.version);
+          idb.version++;
+        }
+
+        repository_fragment_object_traits::load_ (sts, *repository_fragment_o, false);
+        sts.load_delayed (0);
+        l.unlock ();
+      }
+    }
+
+    // repository_fragment post
+    //
+    {
+      if (repository_fragment_o != 0)
+      {
+        repository_fragment_object_traits::callback (*db, *repository_fragment_o, callback_event::post_load);
+        repository_fragment_cache_traits::load (repository_fragment_ig.position ());
+        repository_fragment_ig.release ();
+        repository_fragment_pg.release ();
+      }
+
+      // If a compiler error points to the line below, then
+      // it most likely means that a pointer used in view
+      // member cannot be initialized from an object pointer.
+      //
+      o.repository_fragment = ::std::shared_ptr< ::bpkg::repository_fragment > (
+        std::move (repository_fragment_p));
+    }
+  }
+
+  access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::query_base_type
+  access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::
+  query_statement (const query_base_type& q)
+  {
+    query_base_type r (
+      "SELECT "
+      "\"package\".\"name\", "
+      "\"package\".\"version_epoch\", "
+      "\"package\".\"version_canonical_upstream\", "
+      "\"package\".\"version_canonical_release\", "
+      "\"package\".\"version_revision\", "
+      "\"package\".\"version_iteration\", "
+      "\"main\".\"repository_fragment\".\"name\", "
+      "\"main\".\"repository_fragment\".\"url\", "
+      "\"main\".\"repository_fragment\".\"type\" ");
+
+    r += "FROM \"main\".\"repository_fragment\"";
+
+    r += " INNER JOIN \"main\".\"available_package_locations\" AS \"pl\" ON";
+    // From package.hxx:1796:5
+    r += "pl.repository_fragment = " + query_columns::repository_fragment::name;
+
+    r += " INNER JOIN \"main\".\"available_package\" AS \"package\" ON";
+    // From package.hxx:1798:5
+    r += "pl.name = " + query_columns::package::id.name + "AND" + "pl.version_epoch = " + query_columns::package::id.version.epoch + "AND" + "pl.version_canonical_upstream = " + query_columns::package::id.version.canonical_upstream + "AND" + "pl.version_canonical_release = " + query_columns::package::id.version.canonical_release + "AND" + "pl.version_revision = " + query_columns::package::id.version.revision + "AND" + "pl.version_iteration = " + query_columns::package::id.version.iteration;
+
+    if (!q.empty ())
+    {
+      r += " ";
+      r += q.clause_prefix ();
+      r += q;
+    }
+
+    return r;
+  }
+
+  result< access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::view_type >
+  access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::
+  query (database& db, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      sqlite::transaction::current ().connection (db));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    const query_base_type& qs (query_statement (q));
+    qs.init_parameters ();
+    shared_ptr<select_statement> st (
+      new (shared) select_statement (
+        conn,
+        qs.clause (),
+        false,
+        true,
+        qs.parameters_binding (),
+        imb));
+
+    st->execute ();
+
+    shared_ptr< odb::view_result_impl<view_type> > r (
+      new (shared) sqlite::view_result_impl<view_type> (
+        qs, st, sts, 0));
+
+    return result<view_type> (r);
+  }
+
+  odb::details::shared_ptr<prepared_query_impl>
+  access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::
+  prepare_query (connection& c, const char* n, const query_base_type& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::connection& conn (
+      static_cast<sqlite::connection&> (c));
+    statements_type& sts (
+      conn.statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    shared_ptr<sqlite::prepared_query_impl> r (
+      new (shared) sqlite::prepared_query_impl (conn));
+    r->name = n;
+    r->execute = &execute_query;
+    r->query = query_statement (q);
+    r->stmt.reset (
+      new (shared) select_statement (
+        conn,
+        r->query.clause (),
+        false,
+        true,
+        r->query.parameters_binding (),
+        imb));
+
+    return r;
+  }
+
+  odb::details::shared_ptr<result_impl>
+  access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::
+  execute_query (prepared_query_impl& q)
+  {
+    using namespace sqlite;
+    using odb::details::shared;
+    using odb::details::shared_ptr;
+
+    sqlite::prepared_query_impl& pq (
+      static_cast<sqlite::prepared_query_impl&> (q));
+    shared_ptr<select_statement> st (
+      odb::details::inc_ref (
+        static_cast<select_statement*> (pq.stmt.get ())));
+
+    sqlite::transaction& tr (sqlite::transaction::current ());
+    ODB_POTENTIALLY_UNUSED (tr);
+
+    // The connection used by the current transaction and the
+    // one used to prepare this statement must be the same.
+    //
+    assert (q.verify_connection (tr));
+
+    statements_type& sts (
+      st->connection ().statement_cache ().find_view<view_type> ());
+
+    image_type& im (sts.image ());
+    binding& imb (sts.image_binding ());
+
+    if (im.version != sts.image_version () || imb.version == 0)
+    {
+      bind (imb.bind, im);
+      sts.image_version (im.version);
+      imb.version++;
+    }
+
+    pq.query.init_parameters ();
+    st->execute ();
+
+    return shared_ptr<result_impl> (
+      new (shared) sqlite::view_result_impl<view_type> (
+        pq.query, st, sts, 0));
+  }
+}
+
+namespace odb
+{
+  static bool
+  create_schema (database& db, unsigned short pass, bool drop)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (pass);
+    ODB_POTENTIALLY_UNUSED (drop);
+
+    if (drop)
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"certificate\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"selected_package_config_variables\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"selected_package_dependency_alternatives\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"selected_package_prerequisites\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"selected_package\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_distribution_values\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_buildfiles\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_tests\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_dependency_alternative_dependencies\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_dependency_alternatives\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_dependencies\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_locations\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package_languages\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"available_package\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"repository_fragments\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"repository\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"repository_fragment_prerequisites\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"repository_fragment_complements\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"repository_fragment\"");
+          db.execute ("DROP TABLE IF EXISTS \"main\".\"configuration\"");
+          db.execute ("CREATE TABLE IF NOT EXISTS \"main\".\"schema_version\" (\n"
+                      "  \"name\" TEXT NOT NULL PRIMARY KEY,\n"
+                      "  \"version\" INTEGER NOT NULL,\n"
+                      "  \"migration\" INTEGER NOT NULL)");
+          db.execute ("DELETE FROM \"main\".\"schema_version\"\n"
+                      "  WHERE \"name\" = ''");
+          return false;
+        }
+      }
+    }
+    else
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          db.execute ("CREATE TABLE \"main\".\"configuration\" (\n"
+                      "  \"id\" INTEGER NULL PRIMARY KEY AUTOINCREMENT,\n"
+                      "  \"uuid\" TEXT NULL,\n"
+                      "  \"name\" TEXT NULL,\n"
+                      "  \"type\" TEXT NULL,\n"
+                      "  \"path\" TEXT NULL,\n"
+                      "  \"explicit\" INTEGER NULL)");
+          db.execute ("CREATE UNIQUE INDEX \"main\".\"configuration_uuid_i\"\n"
+                      "  ON \"configuration\" (\"uuid\")");
+          db.execute ("CREATE UNIQUE INDEX \"main\".\"configuration_name_i\"\n"
+                      "  ON \"configuration\" (\"name\")");
+          db.execute ("CREATE UNIQUE INDEX \"main\".\"configuration_path_i\"\n"
+                      "  ON \"configuration\" (\"path\")");
+          db.execute ("CREATE TABLE \"main\".\"repository_fragment\" (\n"
+                      "  \"name\" TEXT NULL PRIMARY KEY,\n"
+                      "  \"url\" TEXT NULL,\n"
+                      "  \"type\" TEXT NULL)");
+          db.execute ("CREATE TABLE \"main\".\"repository_fragment_complements\" (\n"
+                      "  \"repository_fragment\" TEXT NULL,\n"
+                      "  \"complement\" TEXT NULL,\n"
+                      "  CONSTRAINT \"repository_fragment_fk\"\n"
+                      "    FOREIGN KEY (\"repository_fragment\")\n"
+                      "    REFERENCES \"repository_fragment\" (\"name\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"complement_fk\"\n"
+                      "    FOREIGN KEY (\"complement\")\n"
+                      "    REFERENCES \"repository\" (\"name\")\n"
+                      "    DEFERRABLE INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"main\".\"repository_fragment_complements_repository_fragment_i\"\n"
+                      "  ON \"repository_fragment_complements\" (\"repository_fragment\")");
+          db.execute ("CREATE TABLE \"main\".\"repository_fragment_prerequisites\" (\n"
+                      "  \"repository_fragment\" TEXT NULL,\n"
+                      "  \"prerequisite\" TEXT NULL,\n"
+                      "  CONSTRAINT \"repository_fragment_fk\"\n"
+                      "    FOREIGN KEY (\"repository_fragment\")\n"
+                      "    REFERENCES \"repository_fragment\" (\"name\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"prerequisite_fk\"\n"
+                      "    FOREIGN KEY (\"prerequisite\")\n"
+                      "    REFERENCES \"repository\" (\"name\")\n"
+                      "    DEFERRABLE INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"main\".\"repository_fragment_prerequisites_repository_fragment_i\"\n"
+                      "  ON \"repository_fragment_prerequisites\" (\"repository_fragment\")");
+          db.execute ("CREATE TABLE \"main\".\"repository\" (\n"
+                      "  \"name\" TEXT NULL PRIMARY KEY,\n"
+                      "  \"url\" TEXT NULL,\n"
+                      "  \"type\" TEXT NULL,\n"
+                      "  \"certificate\" TEXT NULL,\n"
+                      "  \"local\" INTEGER NULL)");
+          db.execute ("CREATE TABLE \"main\".\"repository_fragments\" (\n"
+                      "  \"repository\" TEXT NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"friendly_name\" TEXT NULL,\n"
+                      "  \"fragment\" TEXT NULL,\n"
+                      "  CONSTRAINT \"repository_fk\"\n"
+                      "    FOREIGN KEY (\"repository\")\n"
+                      "    REFERENCES \"repository\" (\"name\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"fragment_fk\"\n"
+                      "    FOREIGN KEY (\"fragment\")\n"
+                      "    REFERENCES \"repository_fragment\" (\"name\")\n"
+                      "    DEFERRABLE INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"main\".\"repository_fragments_repository_i\"\n"
+                      "  ON \"repository_fragments\" (\"repository\")");
+          db.execute ("CREATE INDEX \"main\".\"repository_fragments_index_i\"\n"
+                      "  ON \"repository_fragments\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"version_upstream\" TEXT NULL,\n"
+                      "  \"version_release\" TEXT NULL,\n"
+                      "  \"upstream_version\" TEXT NULL,\n"
+                      "  \"type\" TEXT NULL,\n"
+                      "  \"project\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"alt_naming\" INTEGER NULL DEFAULT 0,\n"
+                      "  \"bootstrap_build\" TEXT NULL DEFAULT '',\n"
+                      "  \"root_build\" TEXT NULL,\n"
+                      "  \"sha256sum\" TEXT NULL,\n"
+                      "  PRIMARY KEY (\"name\",\n"
+                      "               \"version_epoch\",\n"
+                      "               \"version_canonical_upstream\",\n"
+                      "               \"version_canonical_release\",\n"
+                      "               \"version_revision\",\n"
+                      "               \"version_iteration\"))");
+          db.execute ("CREATE TABLE \"main\".\"available_package_languages\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"language_name\" TEXT NULL,\n"
+                      "  \"language_impl\" INTEGER NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_languages_object_id_i\"\n"
+                      "  ON \"available_package_languages\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE INDEX \"main\".\"available_package_languages_index_i\"\n"
+                      "  ON \"available_package_languages\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package_locations\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"repository_fragment\" TEXT NULL,\n"
+                      "  \"location\" TEXT NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE,\n"
+                      "  CONSTRAINT \"repository_fragment_fk\"\n"
+                      "    FOREIGN KEY (\"repository_fragment\")\n"
+                      "    REFERENCES \"repository_fragment\" (\"name\")\n"
+                      "    DEFERRABLE INITIALLY DEFERRED)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_locations_object_id_i\"\n"
+                      "  ON \"available_package_locations\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package_dependencies\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"buildtime\" INTEGER NULL,\n"
+                      "  \"comment\" TEXT NULL,\n"
+                      "  \"type\" TEXT NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_dependencies_object_id_i\"\n"
+                      "  ON \"available_package_dependencies\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE INDEX \"main\".\"available_package_dependencies_index_i\"\n"
+                      "  ON \"available_package_dependencies\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package_dependency_alternatives\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"dependency_index\" INTEGER NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"enable\" TEXT NULL,\n"
+                      "  \"reflect\" TEXT NULL,\n"
+                      "  \"prefer\" TEXT NULL,\n"
+                      "  \"accept\" TEXT NULL,\n"
+                      "  \"require\" TEXT NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_dependency_alternatives_object_id_i\"\n"
+                      "  ON \"available_package_dependency_alternatives\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package_dependency_alternative_dependencies\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"dependency_index\" INTEGER NULL,\n"
+                      "  \"alternative_index\" INTEGER NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"dep_name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"dep_min_version_epoch\" INTEGER NULL,\n"
+                      "  \"dep_min_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"dep_min_version_canonical_release\" TEXT NULL,\n"
+                      "  \"dep_min_version_revision\" INTEGER NULL,\n"
+                      "  \"dep_min_version_iteration\" INTEGER NULL,\n"
+                      "  \"dep_min_version_upstream\" TEXT NULL,\n"
+                      "  \"dep_min_version_release\" TEXT NULL,\n"
+                      "  \"dep_max_version_epoch\" INTEGER NULL,\n"
+                      "  \"dep_max_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"dep_max_version_canonical_release\" TEXT NULL,\n"
+                      "  \"dep_max_version_revision\" INTEGER NULL,\n"
+                      "  \"dep_max_version_iteration\" INTEGER NULL,\n"
+                      "  \"dep_max_version_upstream\" TEXT NULL,\n"
+                      "  \"dep_max_version_release\" TEXT NULL,\n"
+                      "  \"dep_min_open\" INTEGER NULL,\n"
+                      "  \"dep_max_open\" INTEGER NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_dependency_alternative_dependencies_object_id_i\"\n"
+                      "  ON \"available_package_dependency_alternative_dependencies\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package_tests\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"test_name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"test_min_version_epoch\" INTEGER NULL,\n"
+                      "  \"test_min_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"test_min_version_canonical_release\" TEXT NULL,\n"
+                      "  \"test_min_version_revision\" INTEGER NULL,\n"
+                      "  \"test_min_version_iteration\" INTEGER NULL,\n"
+                      "  \"test_min_version_upstream\" TEXT NULL,\n"
+                      "  \"test_min_version_release\" TEXT NULL,\n"
+                      "  \"test_max_version_epoch\" INTEGER NULL,\n"
+                      "  \"test_max_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"test_max_version_canonical_release\" TEXT NULL,\n"
+                      "  \"test_max_version_revision\" INTEGER NULL,\n"
+                      "  \"test_max_version_iteration\" INTEGER NULL,\n"
+                      "  \"test_max_version_upstream\" TEXT NULL,\n"
+                      "  \"test_max_version_release\" TEXT NULL,\n"
+                      "  \"test_min_open\" INTEGER NULL,\n"
+                      "  \"test_max_open\" INTEGER NULL,\n"
+                      "  \"test_type\" TEXT NULL,\n"
+                      "  \"test_buildtime\" INTEGER NULL DEFAULT 0,\n"
+                      "  \"test_enable\" TEXT NULL,\n"
+                      "  \"test_reflect\" TEXT NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_tests_object_id_i\"\n"
+                      "  ON \"available_package_tests\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE INDEX \"main\".\"available_package_tests_index_i\"\n"
+                      "  ON \"available_package_tests\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package_buildfiles\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"path\" TEXT NULL,\n"
+                      "  \"content\" TEXT NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_buildfiles_object_id_i\"\n"
+                      "  ON \"available_package_buildfiles\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE INDEX \"main\".\"available_package_buildfiles_index_i\"\n"
+                      "  ON \"available_package_buildfiles\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"available_package_distribution_values\" (\n"
+                      "  \"name\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL COLLATE BINARY,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"dist_name\" TEXT NULL,\n"
+                      "  \"dist_value\" TEXT NULL,\n"
+                      "  CONSTRAINT \"object_id_fk\"\n"
+                      "    FOREIGN KEY (\"name\",\n"
+                      "                 \"version_epoch\",\n"
+                      "                 \"version_canonical_upstream\",\n"
+                      "                 \"version_canonical_release\",\n"
+                      "                 \"version_revision\",\n"
+                      "                 \"version_iteration\")\n"
+                      "    REFERENCES \"available_package\" (\"name\",\n"
+                      "                                    \"version_epoch\",\n"
+                      "                                    \"version_canonical_upstream\",\n"
+                      "                                    \"version_canonical_release\",\n"
+                      "                                    \"version_revision\",\n"
+                      "                                    \"version_iteration\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"available_package_distribution_values_object_id_i\"\n"
+                      "  ON \"available_package_distribution_values\" (\n"
+                      "    \"name\",\n"
+                      "    \"version_epoch\",\n"
+                      "    \"version_canonical_upstream\",\n"
+                      "    \"version_canonical_release\",\n"
+                      "    \"version_revision\",\n"
+                      "    \"version_iteration\")");
+          db.execute ("CREATE INDEX \"main\".\"available_package_distribution_values_index_i\"\n"
+                      "  ON \"available_package_distribution_values\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"selected_package\" (\n"
+                      "  \"name\" TEXT NULL PRIMARY KEY COLLATE NOCASE,\n"
+                      "  \"version_epoch\" INTEGER NULL,\n"
+                      "  \"version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"version_canonical_release\" TEXT NULL,\n"
+                      "  \"version_revision\" INTEGER NULL,\n"
+                      "  \"version_iteration\" INTEGER NULL,\n"
+                      "  \"version_upstream\" TEXT NULL,\n"
+                      "  \"version_release\" TEXT NULL,\n"
+                      "  \"state\" TEXT NULL,\n"
+                      "  \"substate\" TEXT NULL,\n"
+                      "  \"hold_package\" INTEGER NULL,\n"
+                      "  \"hold_version\" INTEGER NULL,\n"
+                      "  \"repository_fragment_url\" TEXT NULL,\n"
+                      "  \"repository_fragment_type\" TEXT NULL,\n"
+                      "  \"archive\" TEXT NULL,\n"
+                      "  \"purge_archive\" INTEGER NULL,\n"
+                      "  \"src_root\" TEXT NULL,\n"
+                      "  \"purge_src\" INTEGER NULL,\n"
+                      "  \"manifest_checksum\" TEXT NULL,\n"
+                      "  \"buildfiles_checksum\" TEXT NULL,\n"
+                      "  \"out_root\" TEXT NULL,\n"
+                      "  \"config_checksum\" TEXT NULL DEFAULT '')");
+          db.execute ("CREATE TABLE \"main\".\"selected_package_prerequisites\" (\n"
+                      "  \"package\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"configuration\" TEXT NULL,\n"
+                      "  \"prerequisite\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"min_version_epoch\" INTEGER NULL,\n"
+                      "  \"min_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"min_version_canonical_release\" TEXT NULL,\n"
+                      "  \"min_version_revision\" INTEGER NULL,\n"
+                      "  \"min_version_iteration\" INTEGER NULL,\n"
+                      "  \"min_version_upstream\" TEXT NULL,\n"
+                      "  \"min_version_release\" TEXT NULL,\n"
+                      "  \"max_version_epoch\" INTEGER NULL,\n"
+                      "  \"max_version_canonical_upstream\" TEXT NULL,\n"
+                      "  \"max_version_canonical_release\" TEXT NULL,\n"
+                      "  \"max_version_revision\" INTEGER NULL,\n"
+                      "  \"max_version_iteration\" INTEGER NULL,\n"
+                      "  \"max_version_upstream\" TEXT NULL,\n"
+                      "  \"max_version_release\" TEXT NULL,\n"
+                      "  \"min_open\" INTEGER NULL,\n"
+                      "  \"max_open\" INTEGER NULL,\n"
+                      "  CONSTRAINT \"package_fk\"\n"
+                      "    FOREIGN KEY (\"package\")\n"
+                      "    REFERENCES \"selected_package\" (\"name\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"selected_package_prerequisites_package_i\"\n"
+                      "  ON \"selected_package_prerequisites\" (\"package\")");
+          db.execute ("CREATE TABLE \"main\".\"selected_package_dependency_alternatives\" (\n"
+                      "  \"package\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"position\" INTEGER NULL,\n"
+                      "  CONSTRAINT \"package_fk\"\n"
+                      "    FOREIGN KEY (\"package\")\n"
+                      "    REFERENCES \"selected_package\" (\"name\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"selected_package_dependency_alternatives_package_i\"\n"
+                      "  ON \"selected_package_dependency_alternatives\" (\"package\")");
+          db.execute ("CREATE INDEX \"main\".\"selected_package_dependency_alternatives_index_i\"\n"
+                      "  ON \"selected_package_dependency_alternatives\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"selected_package_config_variables\" (\n"
+                      "  \"package\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"name\" TEXT NULL,\n"
+                      "  \"source\" TEXT NULL,\n"
+                      "  CONSTRAINT \"package_fk\"\n"
+                      "    FOREIGN KEY (\"package\")\n"
+                      "    REFERENCES \"selected_package\" (\"name\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"selected_package_config_variables_package_i\"\n"
+                      "  ON \"selected_package_config_variables\" (\"package\")");
+          db.execute ("CREATE INDEX \"main\".\"selected_package_config_variables_index_i\"\n"
+                      "  ON \"selected_package_config_variables\" (\"index\")");
+          db.execute ("CREATE TABLE \"main\".\"certificate\" (\n"
+                      "  \"id\" TEXT NULL PRIMARY KEY,\n"
+                      "  \"fingerprint\" TEXT NULL,\n"
+                      "  \"name\" TEXT NULL,\n"
+                      "  \"organization\" TEXT NULL,\n"
+                      "  \"email\" TEXT NULL,\n"
+                      "  \"start_date\" INTEGER NULL,\n"
+                      "  \"end_date\" INTEGER NULL)");
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("CREATE TABLE IF NOT EXISTS \"main\".\"schema_version\" (\n"
+                      "  \"name\" TEXT NOT NULL PRIMARY KEY,\n"
+                      "  \"version\" INTEGER NOT NULL,\n"
+                      "  \"migration\" INTEGER NOT NULL)");
+          db.execute ("INSERT OR IGNORE INTO \"main\".\"schema_version\" (\n"
+                      "  \"name\", \"version\", \"migration\")\n"
+                      "  VALUES ('', 26, 0)");
+          return false;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  static const schema_catalog_create_entry
+  create_schema_entry_ (
+    id_sqlite,
+    "",
+    &create_schema);
+
+  static const schema_catalog_migrate_entry
+  migrate_schema_entry_23_ (
+    id_sqlite,
+    "",
+    23ULL,
+    0);
+
+  static bool
+  migrate_schema_24 (database& db, unsigned short pass, bool pre)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (pass);
+    ODB_POTENTIALLY_UNUSED (pre);
+
+    if (pre)
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          db.execute ("ALTER TABLE \"main\".\"selected_package\"\n"
+                      "  ADD COLUMN \"config_checksum\" TEXT NULL DEFAULT ''");
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("UPDATE \"main\".\"schema_version\"\n"
+                      "  SET \"version\" = 24, \"migration\" = 1\n"
+                      "  WHERE \"name\" = ''");
+          return false;
+        }
+      }
+    }
+    else
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("UPDATE \"main\".\"schema_version\"\n"
+                      "  SET \"migration\" = 0\n"
+                      "  WHERE \"name\" = ''");
+          return false;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  static const schema_catalog_migrate_entry
+  migrate_schema_entry_24_ (
+    id_sqlite,
+    "",
+    24ULL,
+    &migrate_schema_24);
+
+  static bool
+  migrate_schema_25 (database& db, unsigned short pass, bool pre)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (pass);
+    ODB_POTENTIALLY_UNUSED (pre);
+
+    if (pre)
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          db.execute ("CREATE TABLE \"main\".\"selected_package_dependency_alternatives\" (\n"
+                      "  \"package\" TEXT NULL COLLATE NOCASE,\n"
+                      "  \"index\" INTEGER NULL,\n"
+                      "  \"position\" INTEGER NULL,\n"
+                      "  CONSTRAINT \"package_fk\"\n"
+                      "    FOREIGN KEY (\"package\")\n"
+                      "    REFERENCES \"selected_package\" (\"name\")\n"
+                      "    ON DELETE CASCADE)");
+          db.execute ("CREATE INDEX \"main\".\"selected_package_dependency_alternatives_package_i\"\n"
+                      "  ON \"selected_package_dependency_alternatives\" (\"package\")");
+          db.execute ("CREATE INDEX \"main\".\"selected_package_dependency_alternatives_index_i\"\n"
+                      "  ON \"selected_package_dependency_alternatives\" (\"index\")");
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("UPDATE \"main\".\"schema_version\"\n"
+                      "  SET \"version\" = 25, \"migration\" = 1\n"
+                      "  WHERE \"name\" = ''");
+          return false;
+        }
+      }
+    }
+    else
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("UPDATE \"main\".\"selected_package_prerequisites\"\n"
+                      "  SET \"config_dependency_index\" = NULL,\n"
+                      "    \"config_alternative_index\" = NULL");
+          db.execute ("UPDATE \"main\".\"schema_version\"\n"
+                      "  SET \"migration\" = 0\n"
+                      "  WHERE \"name\" = ''");
+          return false;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  static const schema_catalog_migrate_entry
+  migrate_schema_entry_25_ (
+    id_sqlite,
+    "",
+    25ULL,
+    &migrate_schema_25);
+
+  static bool
+  migrate_schema_26 (database& db, unsigned short pass, bool pre)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (pass);
+    ODB_POTENTIALLY_UNUSED (pre);
+
+    if (pre)
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          db.execute ("ALTER TABLE \"main\".\"available_package_tests\"\n"
+                      "  ADD COLUMN \"test_enable\" TEXT NULL");
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("UPDATE \"main\".\"schema_version\"\n"
+                      "  SET \"version\" = 26, \"migration\" = 1\n"
+                      "  WHERE \"name\" = ''");
+          return false;
+        }
+      }
+    }
+    else
+    {
+      switch (pass)
+      {
+        case 1:
+        {
+          return true;
+        }
+        case 2:
+        {
+          db.execute ("UPDATE \"main\".\"schema_version\"\n"
+                      "  SET \"migration\" = 0\n"
+                      "  WHERE \"name\" = ''");
+          return false;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  static const schema_catalog_migrate_entry
+  migrate_schema_entry_26_ (
+    id_sqlite,
+    "",
+    26ULL,
+    &migrate_schema_26);
+}
+
+#include <odb/post.hxx>
diff --git a/bpkg/package-odb.hxx b/bpkg/package-odb.hxx
new file mode 100644
index 0000000..a60efde
--- /dev/null
+++ b/bpkg/package-odb.hxx
@@ -0,0 +1,6023 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+#ifndef BPKG_PACKAGE_ODB_HXX
+#define BPKG_PACKAGE_ODB_HXX
+
+// Begin prologue.
+//
+#include <libbutl/small-vector-odb.hxx>
+#include <bpkg/pointer-traits.hxx>
+#include <bpkg/wrapper-traits.hxx>
+#include <bpkg/value-traits.hxx>
+//
+// End prologue.
+
+#include <odb/version.hxx>
+
+#if ODB_VERSION != 20478UL
+#error ODB runtime version mismatch
+#endif
+
+#include <odb/pre.hxx>
+
+#include <bpkg/package.hxx>
+
+#include <memory>
+#include <cstddef>
+#include <utility>
+
+#include <odb/core.hxx>
+#include <odb/traits.hxx>
+#include <odb/callback.hxx>
+#include <odb/wrapper-traits.hxx>
+#include <odb/pointer-traits.hxx>
+#include <odb/container-traits.hxx>
+#include <odb/session.hxx>
+#include <odb/cache-traits.hxx>
+#include <odb/prepared-query.hxx>
+#include <odb/result.hxx>
+#include <odb/simple-object-result.hxx>
+#include <odb/view-image.hxx>
+#include <odb/view-result.hxx>
+
+#include <odb/details/unused.hxx>
+#include <odb/details/shared-ptr.hxx>
+
+namespace odb
+{
+  // configuration
+  //
+  template <>
+  struct class_traits< ::bpkg::configuration >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::bpkg::configuration >
+  {
+    public:
+    typedef ::bpkg::configuration object_type;
+    typedef ::std::shared_ptr< ::bpkg::configuration > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::bpkg::optional_uint64_t id_type;
+
+    static const bool auto_id = true;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    no_op_pointer_cache_traits<pointer_type>
+    pointer_cache_traits;
+
+    typedef
+    no_op_reference_cache_traits<object_type>
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // repository_fragment
+  //
+  template <>
+  struct class_traits< ::bpkg::repository_fragment >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::bpkg::repository_fragment >
+  {
+    public:
+    typedef ::bpkg::repository_fragment object_type;
+    typedef ::std::shared_ptr< ::bpkg::repository_fragment > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::std::string id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // repository_fragment_count
+  //
+  template <>
+  struct class_traits< ::bpkg::repository_fragment_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::repository_fragment_count >
+  {
+    public:
+    typedef ::bpkg::repository_fragment_count view_type;
+    typedef ::bpkg::repository_fragment_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // repository
+  //
+  template <>
+  struct class_traits< ::bpkg::repository >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::bpkg::repository >
+  {
+    public:
+    typedef ::bpkg::repository object_type;
+    typedef ::std::shared_ptr< ::bpkg::repository > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::std::string id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // repository_count
+  //
+  template <>
+  struct class_traits< ::bpkg::repository_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::repository_count >
+  {
+    public:
+    typedef ::bpkg::repository_count view_type;
+    typedef ::bpkg::repository_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // available_package
+  //
+  template <>
+  struct class_traits< ::bpkg::available_package >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::bpkg::available_package >
+  {
+    public:
+    typedef ::bpkg::available_package object_type;
+    typedef ::std::shared_ptr< ::bpkg::available_package > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::bpkg::available_package_id id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // available_package_count
+  //
+  template <>
+  struct class_traits< ::bpkg::available_package_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::available_package_count >
+  {
+    public:
+    typedef ::bpkg::available_package_count view_type;
+    typedef ::bpkg::available_package_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // available_test
+  //
+  template <>
+  struct class_traits< ::bpkg::available_test >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::available_test >
+  {
+    public:
+    typedef ::bpkg::available_test view_type;
+    typedef ::bpkg::available_test* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // available_main
+  //
+  template <>
+  struct class_traits< ::bpkg::available_main >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::available_main >
+  {
+    public:
+    typedef ::bpkg::available_main view_type;
+    typedef ::bpkg::available_main* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // selected_package
+  //
+  template <>
+  struct class_traits< ::bpkg::selected_package >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::bpkg::selected_package >
+  {
+    public:
+    typedef ::bpkg::selected_package object_type;
+    typedef ::std::shared_ptr< ::bpkg::selected_package > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::bpkg::package_name id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // certificate
+  //
+  template <>
+  struct class_traits< ::bpkg::certificate >
+  {
+    static const class_kind kind = class_object;
+  };
+
+  template <>
+  class access::object_traits< ::bpkg::certificate >
+  {
+    public:
+    typedef ::bpkg::certificate object_type;
+    typedef ::std::shared_ptr< ::bpkg::certificate > pointer_type;
+    typedef odb::pointer_traits<pointer_type> pointer_traits;
+
+    static const bool polymorphic = false;
+
+    typedef ::std::string id_type;
+
+    static const bool auto_id = false;
+
+    static const bool abstract = false;
+
+    static id_type
+    id (const object_type&);
+
+    typedef
+    odb::pointer_cache_traits<
+      pointer_type,
+      odb::session >
+    pointer_cache_traits;
+
+    typedef
+    odb::reference_cache_traits<
+      object_type,
+      odb::session >
+    reference_cache_traits;
+
+    static void
+    callback (database&, object_type&, callback_event);
+
+    static void
+    callback (database&, const object_type&, callback_event);
+  };
+
+  // package_dependent
+  //
+  template <>
+  struct class_traits< ::bpkg::package_dependent >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::package_dependent >
+  {
+    public:
+    typedef ::bpkg::package_dependent view_type;
+    typedef ::bpkg::package_dependent* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // fragment_repository_count
+  //
+  template <>
+  struct class_traits< ::bpkg::fragment_repository_count >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::fragment_repository_count >
+  {
+    public:
+    typedef ::bpkg::fragment_repository_count view_type;
+    typedef ::bpkg::fragment_repository_count* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // fragment_repository
+  //
+  template <>
+  struct class_traits< ::bpkg::fragment_repository >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::fragment_repository >
+  {
+    public:
+    typedef ::bpkg::fragment_repository view_type;
+    typedef ::bpkg::fragment_repository* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // repository_complement_dependent
+  //
+  template <>
+  struct class_traits< ::bpkg::repository_complement_dependent >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::repository_complement_dependent >
+  {
+    public:
+    typedef ::bpkg::repository_complement_dependent view_type;
+    typedef ::bpkg::repository_complement_dependent* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // repository_prerequisite_dependent
+  //
+  template <>
+  struct class_traits< ::bpkg::repository_prerequisite_dependent >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::repository_prerequisite_dependent >
+  {
+    public:
+    typedef ::bpkg::repository_prerequisite_dependent view_type;
+    typedef ::bpkg::repository_prerequisite_dependent* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // repository_fragment_package
+  //
+  template <>
+  struct class_traits< ::bpkg::repository_fragment_package >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::repository_fragment_package >
+  {
+    public:
+    typedef ::bpkg::repository_fragment_package view_type;
+    typedef ::bpkg::repository_fragment_package* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+
+  // package_repository_fragment
+  //
+  template <>
+  struct class_traits< ::bpkg::package_repository_fragment >
+  {
+    static const class_kind kind = class_view;
+  };
+
+  template <>
+  class access::view_traits< ::bpkg::package_repository_fragment >
+  {
+    public:
+    typedef ::bpkg::package_repository_fragment view_type;
+    typedef ::bpkg::package_repository_fragment* pointer_type;
+
+    static void
+    callback (database&, view_type&, callback_event);
+  };
+}
+
+#include <odb/details/buffer.hxx>
+
+#include <odb/sqlite/version.hxx>
+#include <odb/sqlite/forward.hxx>
+#include <odb/sqlite/binding.hxx>
+#include <odb/sqlite/sqlite-types.hxx>
+#include <odb/sqlite/query.hxx>
+
+namespace odb
+{
+  // _version
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::_version, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::_version value_type;
+
+    struct image_type
+    {
+      // epoch
+      //
+      long long epoch_value;
+      bool epoch_null;
+
+      // canonical_upstream
+      //
+      details::buffer canonical_upstream_value;
+      std::size_t canonical_upstream_size;
+      bool canonical_upstream_null;
+
+      // canonical_release
+      //
+      details::buffer canonical_release_value;
+      std::size_t canonical_release_size;
+      bool canonical_release_null;
+
+      // revision
+      //
+      long long revision_value;
+      bool revision_null;
+
+      // iteration
+      //
+      long long iteration_value;
+      bool iteration_null;
+
+      // upstream
+      //
+      details::buffer upstream_value;
+      std::size_t upstream_size;
+      bool upstream_null;
+
+      // release
+      //
+      details::buffer release_value;
+      std::size_t release_size;
+      bool release_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 7UL;
+  };
+
+  // language
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::language, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::language value_type;
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // impl
+      //
+      long long impl_value;
+      bool impl_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // version_constraint
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::version_constraint, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::version_constraint value_type;
+
+    struct image_type
+    {
+      // min_version
+      //
+      composite_value_traits< ::bpkg::_version, id_sqlite >::image_type min_version_value;
+
+      // max_version
+      //
+      composite_value_traits< ::bpkg::_version, id_sqlite >::image_type max_version_value;
+
+      // min_open
+      //
+      long long min_open_value;
+      bool min_open_null;
+
+      // max_open
+      //
+      long long max_open_value;
+      bool max_open_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 16UL;
+  };
+
+  // dependency
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::dependency, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::dependency value_type;
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // constraint
+      //
+      composite_value_traits< ::bpkg::version_constraint, id_sqlite >::image_type constraint_value;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 17UL;
+  };
+
+  // dependency_alternative
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::dependency_alternative, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::dependency_alternative value_type;
+
+    struct image_type
+    {
+      // enable
+      //
+      details::buffer enable_value;
+      std::size_t enable_size;
+      bool enable_null;
+
+      // reflect
+      //
+      details::buffer reflect_value;
+      std::size_t reflect_size;
+      bool reflect_null;
+
+      // prefer
+      //
+      details::buffer prefer_value;
+      std::size_t prefer_size;
+      bool prefer_null;
+
+      // accept
+      //
+      details::buffer accept_value;
+      std::size_t accept_size;
+      bool accept_null;
+
+      // require
+      //
+      details::buffer require_value;
+      std::size_t require_size;
+      bool require_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 5UL;
+  };
+
+  // dependency_alternatives
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::dependency_alternatives value_type;
+
+    struct image_type
+    {
+      // buildtime
+      //
+      long long buildtime_value;
+      bool buildtime_null;
+
+      // comment
+      //
+      details::buffer comment_value;
+      std::size_t comment_size;
+      bool comment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // test_dependency
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::test_dependency, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::test_dependency value_type;
+
+    struct image_type: composite_value_traits< ::bpkg::dependency, id_sqlite >::image_type
+    {
+      // type
+      //
+      details::buffer type_value;
+      std::size_t type_size;
+      bool type_null;
+
+      // buildtime
+      //
+      long long buildtime_value;
+      bool buildtime_null;
+
+      // enable
+      //
+      details::buffer enable_value;
+      std::size_t enable_size;
+      bool enable_null;
+
+      // reflect
+      //
+      details::buffer reflect_value;
+      std::size_t reflect_size;
+      bool reflect_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 21UL;
+  };
+
+  // buildfile
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::buildfile, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::buildfile value_type;
+
+    struct image_type
+    {
+      // path
+      //
+      details::buffer path_value;
+      std::size_t path_size;
+      bool path_null;
+
+      // content
+      //
+      details::buffer content_value;
+      std::size_t content_size;
+      bool content_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // distribution_name_value
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::distribution_name_value, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::distribution_name_value value_type;
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // value
+      //
+      details::buffer value_value;
+      std::size_t value_size;
+      bool value_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // configuration
+  //
+  template <typename A>
+  struct query_columns< ::bpkg::configuration, id_sqlite, A >
+  {
+    // id
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        long unsigned int,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    id_type_;
+
+    static const id_type_ id;
+
+    // uuid
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    uuid_type_;
+
+    static const uuid_type_ uuid;
+
+    // name
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    name_type_;
+
+    static const name_type_ name;
+
+    // type
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    type_type_;
+
+    static const type_type_ type;
+
+    // path
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    path_type_;
+
+    static const path_type_ path;
+
+    // expl
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        bool,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    expl_type_;
+
+    static const expl_type_ expl;
+  };
+
+  template <typename A>
+  const typename query_columns< ::bpkg::configuration, id_sqlite, A >::id_type_
+  query_columns< ::bpkg::configuration, id_sqlite, A >::
+  id (A::table_name, "\"id\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::configuration, id_sqlite, A >::uuid_type_
+  query_columns< ::bpkg::configuration, id_sqlite, A >::
+  uuid (A::table_name, "\"uuid\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::configuration, id_sqlite, A >::name_type_
+  query_columns< ::bpkg::configuration, id_sqlite, A >::
+  name (A::table_name, "\"name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::configuration, id_sqlite, A >::type_type_
+  query_columns< ::bpkg::configuration, id_sqlite, A >::
+  type (A::table_name, "\"type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::configuration, id_sqlite, A >::path_type_
+  query_columns< ::bpkg::configuration, id_sqlite, A >::
+  path (A::table_name, "\"path\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::configuration, id_sqlite, A >::expl_type_
+  query_columns< ::bpkg::configuration, id_sqlite, A >::
+  expl (A::table_name, "\"explicit\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::bpkg::configuration, id_sqlite, A >:
+    query_columns< ::bpkg::configuration, id_sqlite, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::configuration, id_sqlite >:
+    public access::object_traits< ::bpkg::configuration >
+  {
+    public:
+    struct id_image_type
+    {
+      long long id_value;
+      bool id_null;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      long long id_value;
+      bool id_null;
+
+      // uuid
+      //
+      details::buffer uuid_value;
+      std::size_t uuid_size;
+      bool uuid_null;
+
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // type
+      //
+      details::buffer type_value;
+      std::size_t type_size;
+      bool type_null;
+
+      // path
+      //
+      details::buffer path_value;
+      std::size_t path_size;
+      bool path_null;
+
+      // expl
+      //
+      long long expl_value;
+      bool expl_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const id_image_type&);
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static void
+    bind (sqlite::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef sqlite::object_statements<object_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+
+    static const std::size_t column_count = 6UL;
+    static const std::size_t id_column_count = 1UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::configuration, id_common >:
+    public access::object_traits_impl< ::bpkg::configuration, id_sqlite >
+  {
+  };
+
+  // canonical_version
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::canonical_version, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::canonical_version value_type;
+
+    struct image_type
+    {
+      // epoch
+      //
+      long long epoch_value;
+      bool epoch_null;
+
+      // canonical_upstream
+      //
+      details::buffer canonical_upstream_value;
+      std::size_t canonical_upstream_size;
+      bool canonical_upstream_null;
+
+      // canonical_release
+      //
+      details::buffer canonical_release_value;
+      std::size_t canonical_release_size;
+      bool canonical_release_null;
+
+      // revision
+      //
+      long long revision_value;
+      bool revision_null;
+
+      // iteration
+      //
+      long long iteration_value;
+      bool iteration_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 5UL;
+  };
+
+  // upstream_version
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::upstream_version, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::upstream_version value_type;
+
+    struct image_type
+    {
+      // upstream_
+      //
+      details::buffer upstream_value;
+      std::size_t upstream_size;
+      bool upstream_null;
+
+      // release_
+      //
+      details::buffer release_value;
+      std::size_t release_size;
+      bool release_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // _repository_location
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::_repository_location, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::_repository_location value_type;
+
+    struct image_type
+    {
+      // url
+      //
+      details::buffer url_value;
+      std::size_t url_size;
+      bool url_null;
+
+      // type
+      //
+      details::buffer type_value;
+      std::size_t type_size;
+      bool type_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // repository_fragment
+  //
+  template <typename A>
+  struct query_columns< ::bpkg::repository_fragment, id_sqlite, A >
+  {
+    // name
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    name_type_;
+
+    static const name_type_ name;
+
+    // location
+    //
+    struct location_class_
+    {
+      location_class_ ()
+      {
+      }
+
+      // url
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      url_type_;
+
+      static const url_type_ url;
+
+      // type
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      type_type_;
+
+      static const type_type_ type;
+    };
+
+    static const location_class_ location;
+  };
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository_fragment, id_sqlite, A >::name_type_
+  query_columns< ::bpkg::repository_fragment, id_sqlite, A >::
+  name (A::table_name, "\"name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository_fragment, id_sqlite, A >::location_class_::url_type_
+  query_columns< ::bpkg::repository_fragment, id_sqlite, A >::location_class_::
+  url (A::table_name, "\"url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository_fragment, id_sqlite, A >::location_class_::type_type_
+  query_columns< ::bpkg::repository_fragment, id_sqlite, A >::location_class_::
+  type (A::table_name, "\"type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository_fragment, id_sqlite, A >::location_class_
+  query_columns< ::bpkg::repository_fragment, id_sqlite, A >::location;
+
+  template <typename A>
+  struct pointer_query_columns< ::bpkg::repository_fragment, id_sqlite, A >:
+    query_columns< ::bpkg::repository_fragment, id_sqlite, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >:
+    public access::object_traits< ::bpkg::repository_fragment >
+  {
+    public:
+    struct id_image_type
+    {
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // location
+      //
+      composite_value_traits< ::bpkg::_repository_location, id_sqlite >::image_type location_value;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // complements
+    //
+    struct complements_traits
+    {
+      static const std::size_t id_column_count = 1UL;
+      static const std::size_t data_column_count = 2UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::bpkg::repository_fragment::dependencies container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef set_functions<value_type> functions_type;
+      typedef sqlite::container_statements< complements_traits > statements_type;
+
+      struct data_image_type
+      {
+        // value
+        //
+        details::buffer value_value;
+        std::size_t value_size;
+        bool value_null;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const value_type&);
+
+      static void
+      init (value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const value_type&, void*);
+
+      static bool
+      select (value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // prerequisites
+    //
+    struct prerequisites_traits
+    {
+      static const std::size_t id_column_count = 1UL;
+      static const std::size_t data_column_count = 2UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::bpkg::repository_fragment::dependencies container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef set_functions<value_type> functions_type;
+      typedef sqlite::container_statements< prerequisites_traits > statements_type;
+
+      struct data_image_type
+      {
+        // value
+        //
+        details::buffer value_value;
+        std::size_t value_size;
+        bool value_null;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const value_type&);
+
+      static void
+      init (value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const value_type&, void*);
+
+      static bool
+      select (value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static void
+    bind (sqlite::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef sqlite::object_statements<object_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+
+    static const std::size_t column_count = 3UL;
+    static const std::size_t id_column_count = 1UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::repository_fragment, id_common >:
+    public access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >
+  {
+  };
+
+  // repository_fragment_count
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >:
+    public access::view_traits< ::bpkg::repository_fragment_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_fragment_count, id_common >:
+    public access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >
+  {
+  };
+
+  // fragment_type
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::repository::fragment_type, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::repository::fragment_type value_type;
+
+    struct image_type
+    {
+      // friendly_name
+      //
+      details::buffer friendly_name_value;
+      std::size_t friendly_name_size;
+      bool friendly_name_null;
+
+      // fragment
+      //
+      details::buffer fragment_value;
+      std::size_t fragment_size;
+      bool fragment_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // repository
+  //
+  template <typename A>
+  struct query_columns< ::bpkg::repository, id_sqlite, A >
+  {
+    // name
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    name_type_;
+
+    static const name_type_ name;
+
+    // location
+    //
+    struct location_class_
+    {
+      location_class_ ()
+      {
+      }
+
+      // url
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      url_type_;
+
+      static const url_type_ url;
+
+      // type
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      type_type_;
+
+      static const type_type_ type;
+    };
+
+    static const location_class_ location;
+
+    // certificate
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    certificate_type_;
+
+    static const certificate_type_ certificate;
+
+    // local
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        bool,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    local_type_;
+
+    static const local_type_ local;
+  };
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository, id_sqlite, A >::name_type_
+  query_columns< ::bpkg::repository, id_sqlite, A >::
+  name (A::table_name, "\"name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository, id_sqlite, A >::location_class_::url_type_
+  query_columns< ::bpkg::repository, id_sqlite, A >::location_class_::
+  url (A::table_name, "\"url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository, id_sqlite, A >::location_class_::type_type_
+  query_columns< ::bpkg::repository, id_sqlite, A >::location_class_::
+  type (A::table_name, "\"type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository, id_sqlite, A >::location_class_
+  query_columns< ::bpkg::repository, id_sqlite, A >::location;
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository, id_sqlite, A >::certificate_type_
+  query_columns< ::bpkg::repository, id_sqlite, A >::
+  certificate (A::table_name, "\"certificate\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::repository, id_sqlite, A >::local_type_
+  query_columns< ::bpkg::repository, id_sqlite, A >::
+  local (A::table_name, "\"local\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::bpkg::repository, id_sqlite, A >:
+    query_columns< ::bpkg::repository, id_sqlite, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::repository, id_sqlite >:
+    public access::object_traits< ::bpkg::repository >
+  {
+    public:
+    struct id_image_type
+    {
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // location
+      //
+      composite_value_traits< ::bpkg::_repository_location, id_sqlite >::image_type location_value;
+
+      // certificate
+      //
+      details::buffer certificate_value;
+      std::size_t certificate_size;
+      bool certificate_null;
+
+      // local
+      //
+      long long local_value;
+      bool local_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // fragments
+    //
+    struct fragments_traits
+    {
+      static const std::size_t id_column_count = 1UL;
+      static const std::size_t data_column_count = 4UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::bpkg::repository::fragments_type container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< fragments_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static void
+    bind (sqlite::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef sqlite::object_statements<object_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+
+    static const std::size_t column_count = 5UL;
+    static const std::size_t id_column_count = 1UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::repository, id_common >:
+    public access::object_traits_impl< ::bpkg::repository, id_sqlite >
+  {
+  };
+
+  // repository_count
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_count, id_sqlite >:
+    public access::view_traits< ::bpkg::repository_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_count, id_common >:
+    public access::view_traits_impl< ::bpkg::repository_count, id_sqlite >
+  {
+  };
+
+  // package_location
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::package_location, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::package_location value_type;
+
+    struct image_type
+    {
+      // repository_fragment
+      //
+      details::buffer repository_fragment_value;
+      std::size_t repository_fragment_size;
+      bool repository_fragment_null;
+
+      // location
+      //
+      details::buffer location_value;
+      std::size_t location_size;
+      bool location_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // dependency_alternatives_ex
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::dependency_alternatives_ex, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::dependency_alternatives_ex value_type;
+
+    struct image_type: composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::image_type
+    {
+      // type
+      //
+      details::buffer type_value;
+      std::size_t type_size;
+      bool type_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 3UL;
+  };
+
+  // available_package_id
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::available_package_id, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::available_package_id value_type;
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // version
+      //
+      composite_value_traits< ::bpkg::canonical_version, id_sqlite >::image_type version_value;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 6UL;
+  };
+
+  // _dependency_alternative_key
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::available_package::_dependency_alternative_key, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::available_package::_dependency_alternative_key value_type;
+
+    struct image_type
+    {
+      // outer
+      //
+      long long outer_value;
+      bool outer_null;
+
+      // inner
+      //
+      long long inner_value;
+      bool inner_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // _dependency_key
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::available_package::_dependency_key, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::available_package::_dependency_key value_type;
+
+    struct image_type
+    {
+      // outer
+      //
+      long long outer_value;
+      bool outer_null;
+
+      // middle
+      //
+      long long middle_value;
+      bool middle_null;
+
+      // inner
+      //
+      long long inner_value;
+      bool inner_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 3UL;
+  };
+
+  // available_package
+  //
+  template <typename A>
+  struct query_columns< ::bpkg::available_package, id_sqlite, A >
+  {
+    // id
+    //
+    struct id_class_
+    {
+      id_class_ ()
+      {
+      }
+
+      // name
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::bpkg::package_name,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      name_type_;
+
+      static const name_type_ name;
+
+      // version
+      //
+      struct version_class_1_
+      {
+        version_class_1_ ()
+        {
+        }
+
+        // epoch
+        //
+        typedef
+        sqlite::query_column<
+          sqlite::value_traits<
+            ::uint16_t,
+            sqlite::id_integer >::query_type,
+          sqlite::id_integer >
+        epoch_type_;
+
+        static const epoch_type_ epoch;
+
+        // canonical_upstream
+        //
+        typedef
+        sqlite::query_column<
+          sqlite::value_traits<
+            ::std::string,
+            sqlite::id_text >::query_type,
+          sqlite::id_text >
+        canonical_upstream_type_;
+
+        static const canonical_upstream_type_ canonical_upstream;
+
+        // canonical_release
+        //
+        typedef
+        sqlite::query_column<
+          sqlite::value_traits<
+            ::std::string,
+            sqlite::id_text >::query_type,
+          sqlite::id_text >
+        canonical_release_type_;
+
+        static const canonical_release_type_ canonical_release;
+
+        // revision
+        //
+        typedef
+        sqlite::query_column<
+          sqlite::value_traits<
+            ::uint16_t,
+            sqlite::id_integer >::query_type,
+          sqlite::id_integer >
+        revision_type_;
+
+        static const revision_type_ revision;
+
+        // iteration
+        //
+        typedef
+        sqlite::query_column<
+          sqlite::value_traits<
+            ::uint32_t,
+            sqlite::id_integer >::query_type,
+          sqlite::id_integer >
+        iteration_type_;
+
+        static const iteration_type_ iteration;
+      };
+
+      static const version_class_1_ version;
+    };
+
+    static const id_class_ id;
+
+    // version
+    //
+    struct version_class_
+    {
+      version_class_ ()
+      {
+      }
+
+      // upstream
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::basic_string< char >,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const version_class_ version;
+
+    // upstream_version
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    upstream_version_type_;
+
+    static const upstream_version_type_ upstream_version;
+
+    // type
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    type_type_;
+
+    static const type_type_ type;
+
+    // project
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::butl::project_name,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    project_type_;
+
+    static const project_type_ project;
+
+    // alt_naming
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        bool,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    alt_naming_type_;
+
+    static const alt_naming_type_ alt_naming;
+
+    // bootstrap_build
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    bootstrap_build_type_;
+
+    static const bootstrap_build_type_ bootstrap_build;
+
+    // root_build
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    root_build_type_;
+
+    static const root_build_type_ root_build;
+
+    // sha256sum
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    sha256sum_type_;
+
+    static const sha256sum_type_ sha256sum;
+  };
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::name_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::
+  name (A::table_name, "\"name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::epoch_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::
+  epoch (A::table_name, "\"version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::canonical_upstream_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::
+  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::canonical_release_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::
+  canonical_release (A::table_name, "\"version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::revision_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::
+  revision (A::table_name, "\"version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::iteration_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_::
+  iteration (A::table_name, "\"version_iteration\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version_class_1_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_::version;
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::id_class_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::id;
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::version_class_::upstream_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::version_class_::
+  upstream (A::table_name, "\"version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::version_class_::release_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::version_class_::
+  release (A::table_name, "\"version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::version_class_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::version;
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::upstream_version_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::
+  upstream_version (A::table_name, "\"upstream_version\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::type_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::
+  type (A::table_name, "\"type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::project_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::
+  project (A::table_name, "\"project\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::alt_naming_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::
+  alt_naming (A::table_name, "\"alt_naming\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::bootstrap_build_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::
+  bootstrap_build (A::table_name, "\"bootstrap_build\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::root_build_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::
+  root_build (A::table_name, "\"root_build\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::available_package, id_sqlite, A >::sha256sum_type_
+  query_columns< ::bpkg::available_package, id_sqlite, A >::
+  sha256sum (A::table_name, "\"sha256sum\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::bpkg::available_package, id_sqlite, A >:
+    query_columns< ::bpkg::available_package, id_sqlite, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::available_package, id_sqlite >:
+    public access::object_traits< ::bpkg::available_package >
+  {
+    public:
+    struct id_image_type
+    {
+      composite_value_traits< ::bpkg::available_package_id, id_sqlite >::image_type id_value;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      composite_value_traits< ::bpkg::available_package_id, id_sqlite >::image_type id_value;
+
+      // version
+      //
+      composite_value_traits< ::bpkg::available_package::upstream_version_type, id_sqlite >::image_type version_value;
+
+      // upstream_version
+      //
+      details::buffer upstream_version_value;
+      std::size_t upstream_version_size;
+      bool upstream_version_null;
+
+      // type
+      //
+      details::buffer type_value;
+      std::size_t type_size;
+      bool type_null;
+
+      // project
+      //
+      details::buffer project_value;
+      std::size_t project_size;
+      bool project_null;
+
+      // alt_naming
+      //
+      long long alt_naming_value;
+      bool alt_naming_null;
+
+      // bootstrap_build
+      //
+      details::buffer bootstrap_build_value;
+      std::size_t bootstrap_build_size;
+      bool bootstrap_build_null;
+
+      // root_build
+      //
+      details::buffer root_build_value;
+      std::size_t root_build_size;
+      bool root_build_null;
+
+      // sha256sum
+      //
+      details::buffer sha256sum_value;
+      std::size_t sha256sum_size;
+      bool sha256sum_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // languages
+    //
+    struct languages_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::butl::small_vector< ::bpkg::language, 1 > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< languages_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // locations
+    //
+    struct locations_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 8UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::butl::small_vector< ::bpkg::package_location, 1 > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< locations_traits > statements_type;
+
+      struct data_image_type
+      {
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const value_type&);
+
+      static void
+      init (value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // dependencies
+    //
+    struct dependencies_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 10UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::bpkg::available_package::dependencies_type container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< dependencies_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // dependency_alternatives
+    //
+    struct dependency_alternatives_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 13UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::map< ::odb::nested_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency_alternative > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::key_type key_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef map_functions<key_type, value_type> functions_type;
+      typedef sqlite::container_statements< dependency_alternatives_traits > statements_type;
+
+      struct data_image_type
+      {
+        // key
+        //
+        composite_value_traits< key_type, id_sqlite >::image_type key_value;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const key_type*,
+            const value_type&);
+
+      static void
+      init (key_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const key_type&, const value_type&, void*);
+
+      static bool
+      select (key_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // dependency_alternative_dependencies
+    //
+    struct dependency_alternative_dependencies_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 26UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::map< ::odb::nested2_key< ::bpkg::dependency_alternatives_ex >, ::bpkg::dependency > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::key_type key_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef map_functions<key_type, value_type> functions_type;
+      typedef sqlite::container_statements< dependency_alternative_dependencies_traits > statements_type;
+
+      struct data_image_type
+      {
+        // key
+        //
+        composite_value_traits< key_type, id_sqlite >::image_type key_value;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const key_type*,
+            const value_type&);
+
+      static void
+      init (key_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const key_type&, const value_type&, void*);
+
+      static bool
+      select (key_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // tests
+    //
+    struct tests_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 28UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::butl::small_vector< ::bpkg::test_dependency, 1 > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< tests_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // buildfiles
+    //
+    struct buildfiles_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::vector< ::bpkg::buildfile > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< buildfiles_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // distribution_values
+    //
+    struct distribution_values_traits
+    {
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t data_column_count = 9UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::vector< ::bpkg::distribution_name_value > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< distribution_values_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // languages_section
+    //
+    struct languages_section_traits
+    {
+      typedef object_traits_impl<object_type, id_sqlite>::image_type image_type;
+      typedef object_traits_impl<object_type, id_sqlite>::id_image_type id_image_type;
+
+      static const std::size_t id_column_count = 6UL;
+      static const std::size_t managed_optimistic_load_column_count = 0UL;
+      static const std::size_t load_column_count = 0UL;
+      static const std::size_t managed_optimistic_update_column_count = 0UL;
+      static const std::size_t update_column_count = 0UL;
+
+      static const bool versioned = false;
+
+      static void
+      load (extra_statement_cache_type&, object_type&);
+
+      static void
+      update (extra_statement_cache_type&, const object_type&);
+    };
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static void
+    bind (sqlite::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef sqlite::object_statements<object_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+
+    static const std::size_t column_count = 15UL;
+    static const std::size_t id_column_count = 6UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static bool
+    load (connection&, object_type&, section&);
+
+    static bool
+    update (connection&, const object_type&, const section&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::available_package, id_common >:
+    public access::object_traits_impl< ::bpkg::available_package, id_sqlite >
+  {
+  };
+
+  // available_package_count
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >:
+    public access::view_traits< ::bpkg::available_package_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::available_package_count, id_common >:
+    public access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >
+  {
+  };
+
+  // available_test
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::available_test, id_sqlite >:
+    public access::view_traits< ::bpkg::available_test >
+  {
+    public:
+    struct image_type
+    {
+      // package
+      //
+      object_traits_impl< ::bpkg::available_package, id_sqlite >::image_type package_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    struct package_tag;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 15UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::available_test, id_common >:
+    public access::view_traits_impl< ::bpkg::available_test, id_sqlite >
+  {
+  };
+
+  // available_main
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::available_main, id_sqlite >:
+    public access::view_traits< ::bpkg::available_main >
+  {
+    public:
+    struct image_type
+    {
+      // package
+      //
+      object_traits_impl< ::bpkg::available_package, id_sqlite >::image_type package_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    struct package_tag;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 15UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::available_main, id_common >:
+    public access::view_traits_impl< ::bpkg::available_main, id_sqlite >
+  {
+  };
+
+  // prerequisite_info
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::prerequisite_info, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::prerequisite_info value_type;
+
+    struct image_type
+    {
+      // constraint
+      //
+      composite_value_traits< ::bpkg::version_constraint, id_sqlite >::image_type constraint_value;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 16UL;
+  };
+
+  // _selected_package_ref
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::_selected_package_ref value_type;
+
+    struct image_type
+    {
+      // configuration
+      //
+      details::buffer configuration_value;
+      std::size_t configuration_size;
+      bool configuration_null;
+
+      // prerequisite
+      //
+      details::buffer prerequisite_value;
+      std::size_t prerequisite_size;
+      bool prerequisite_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // config_variable
+  //
+  template <>
+  class access::composite_value_traits< ::bpkg::config_variable, id_sqlite >
+  {
+    public:
+    typedef ::bpkg::config_variable value_type;
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // source
+      //
+      details::buffer source_value;
+      std::size_t source_size;
+      bool source_null;
+    };
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static bool
+    init (image_type&,
+          const value_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (value_type&,
+          const image_type&,
+          database*);
+
+    static bool
+    get_null (const image_type&);
+
+    static void
+    set_null (image_type&,
+              sqlite::statement_kind);
+
+    static const std::size_t column_count = 2UL;
+  };
+
+  // selected_package
+  //
+  template <typename A>
+  struct query_columns< ::bpkg::selected_package, id_sqlite, A >
+  {
+    // name
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::bpkg::package_name,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    name_type_;
+
+    static const name_type_ name;
+
+    // version
+    //
+    struct version_class_
+    {
+      version_class_ ()
+      {
+      }
+
+      // epoch
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::uint16_t,
+          sqlite::id_integer >::query_type,
+        sqlite::id_integer >
+      epoch_type_;
+
+      static const epoch_type_ epoch;
+
+      // canonical_upstream
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      canonical_upstream_type_;
+
+      static const canonical_upstream_type_ canonical_upstream;
+
+      // canonical_release
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      canonical_release_type_;
+
+      static const canonical_release_type_ canonical_release;
+
+      // revision
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          short unsigned int,
+          sqlite::id_integer >::query_type,
+        sqlite::id_integer >
+      revision_type_;
+
+      static const revision_type_ revision;
+
+      // iteration
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::uint32_t,
+          sqlite::id_integer >::query_type,
+        sqlite::id_integer >
+      iteration_type_;
+
+      static const iteration_type_ iteration;
+
+      // upstream
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      upstream_type_;
+
+      static const upstream_type_ upstream;
+
+      // release
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::basic_string< char >,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      release_type_;
+
+      static const release_type_ release;
+    };
+
+    static const version_class_ version;
+
+    // state
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    state_type_;
+
+    static const state_type_ state;
+
+    // substate
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    substate_type_;
+
+    static const substate_type_ substate;
+
+    // hold_package
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        bool,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    hold_package_type_;
+
+    static const hold_package_type_ hold_package;
+
+    // hold_version
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        bool,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    hold_version_type_;
+
+    static const hold_version_type_ hold_version;
+
+    // repository_fragment
+    //
+    struct repository_fragment_class_
+    {
+      repository_fragment_class_ ()
+      {
+      }
+
+      // url
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      url_type_;
+
+      static const url_type_ url;
+
+      // type
+      //
+      typedef
+      sqlite::query_column<
+        sqlite::value_traits<
+          ::std::string,
+          sqlite::id_text >::query_type,
+        sqlite::id_text >
+      type_type_;
+
+      static const type_type_ type;
+    };
+
+    static const repository_fragment_class_ repository_fragment;
+
+    // archive
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    archive_type_;
+
+    static const archive_type_ archive;
+
+    // purge_archive
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        bool,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    purge_archive_type_;
+
+    static const purge_archive_type_ purge_archive;
+
+    // src_root
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    src_root_type_;
+
+    static const src_root_type_ src_root;
+
+    // purge_src
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        bool,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    purge_src_type_;
+
+    static const purge_src_type_ purge_src;
+
+    // manifest_checksum
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    manifest_checksum_type_;
+
+    static const manifest_checksum_type_ manifest_checksum;
+
+    // buildfiles_checksum
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    buildfiles_checksum_type_;
+
+    static const buildfiles_checksum_type_ buildfiles_checksum;
+
+    // out_root
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::basic_string< char >,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    out_root_type_;
+
+    static const out_root_type_ out_root;
+
+    // config_checksum
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    config_checksum_type_;
+
+    static const config_checksum_type_ config_checksum;
+  };
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::name_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  name (A::table_name, "\"name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::epoch_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::
+  epoch (A::table_name, "\"version_epoch\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::canonical_upstream_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::
+  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::canonical_release_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::
+  canonical_release (A::table_name, "\"version_canonical_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::revision_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::
+  revision (A::table_name, "\"version_revision\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::iteration_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::
+  iteration (A::table_name, "\"version_iteration\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::upstream_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::
+  upstream (A::table_name, "\"version_upstream\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::release_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_::
+  release (A::table_name, "\"version_release\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::version_class_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::version;
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::state_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  state (A::table_name, "\"state\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::substate_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  substate (A::table_name, "\"substate\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::hold_package_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  hold_package (A::table_name, "\"hold_package\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::hold_version_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  hold_version (A::table_name, "\"hold_version\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::repository_fragment_class_::url_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::repository_fragment_class_::
+  url (A::table_name, "\"repository_fragment_url\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::repository_fragment_class_::type_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::repository_fragment_class_::
+  type (A::table_name, "\"repository_fragment_type\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::repository_fragment_class_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::repository_fragment;
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::archive_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  archive (A::table_name, "\"archive\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::purge_archive_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  purge_archive (A::table_name, "\"purge_archive\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::src_root_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  src_root (A::table_name, "\"src_root\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::purge_src_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  purge_src (A::table_name, "\"purge_src\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::manifest_checksum_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  manifest_checksum (A::table_name, "\"manifest_checksum\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::buildfiles_checksum_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  buildfiles_checksum (A::table_name, "\"buildfiles_checksum\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::out_root_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  out_root (A::table_name, "\"out_root\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::selected_package, id_sqlite, A >::config_checksum_type_
+  query_columns< ::bpkg::selected_package, id_sqlite, A >::
+  config_checksum (A::table_name, "\"config_checksum\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::bpkg::selected_package, id_sqlite, A >:
+    query_columns< ::bpkg::selected_package, id_sqlite, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::selected_package, id_sqlite >:
+    public access::object_traits< ::bpkg::selected_package >
+  {
+    public:
+    struct id_image_type
+    {
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // version
+      //
+      composite_value_traits< ::bpkg::_version, id_sqlite >::image_type version_value;
+
+      // state
+      //
+      details::buffer state_value;
+      std::size_t state_size;
+      bool state_null;
+
+      // substate
+      //
+      details::buffer substate_value;
+      std::size_t substate_size;
+      bool substate_null;
+
+      // hold_package
+      //
+      long long hold_package_value;
+      bool hold_package_null;
+
+      // hold_version
+      //
+      long long hold_version_value;
+      bool hold_version_null;
+
+      // repository_fragment
+      //
+      composite_value_traits< ::bpkg::_repository_location, id_sqlite >::image_type repository_fragment_value;
+
+      // archive
+      //
+      details::buffer archive_value;
+      std::size_t archive_size;
+      bool archive_null;
+
+      // purge_archive
+      //
+      long long purge_archive_value;
+      bool purge_archive_null;
+
+      // src_root
+      //
+      details::buffer src_root_value;
+      std::size_t src_root_size;
+      bool src_root_null;
+
+      // purge_src
+      //
+      long long purge_src_value;
+      bool purge_src_null;
+
+      // manifest_checksum
+      //
+      details::buffer manifest_checksum_value;
+      std::size_t manifest_checksum_size;
+      bool manifest_checksum_null;
+
+      // buildfiles_checksum
+      //
+      details::buffer buildfiles_checksum_value;
+      std::size_t buildfiles_checksum_size;
+      bool buildfiles_checksum_null;
+
+      // out_root
+      //
+      details::buffer out_root_value;
+      std::size_t out_root_size;
+      bool out_root_null;
+
+      // config_checksum
+      //
+      details::buffer config_checksum_value;
+      std::size_t config_checksum_size;
+      bool config_checksum_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    // prerequisites
+    //
+    struct prerequisites_traits
+    {
+      static const std::size_t id_column_count = 1UL;
+      static const std::size_t data_column_count = 19UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::bpkg::package_prerequisites container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::key_type key_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef map_functions<key_type, value_type> functions_type;
+      typedef sqlite::container_statements< prerequisites_traits > statements_type;
+
+      struct data_image_type
+      {
+        // key
+        //
+        composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::image_type key_value;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            const key_type*,
+            const value_type&);
+
+      static void
+      init (key_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (const key_type&, const value_type&, void*);
+
+      static bool
+      select (key_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // dependency_alternatives
+    //
+    struct dependency_alternatives_traits
+    {
+      static const std::size_t id_column_count = 1UL;
+      static const std::size_t data_column_count = 3UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::bpkg::selected_package::indexes_type container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< dependency_alternatives_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        long long value_value;
+        bool value_null;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // config_variables
+    //
+    struct config_variables_traits
+    {
+      static const std::size_t id_column_count = 1UL;
+      static const std::size_t data_column_count = 4UL;
+
+      static const bool versioned = false;
+
+      static const char insert_statement[];
+      static const char select_statement[];
+      static const char delete_statement[];
+
+      typedef ::std::vector< ::bpkg::config_variable > container_type;
+      typedef
+      odb::access::container_traits<container_type>
+      container_traits_type;
+      typedef container_traits_type::index_type index_type;
+      typedef container_traits_type::value_type value_type;
+
+      typedef ordered_functions<index_type, value_type> functions_type;
+      typedef sqlite::container_statements< config_variables_traits > statements_type;
+
+      struct data_image_type
+      {
+        // index
+        //
+        long long index_value;
+        bool index_null;
+
+        // value
+        //
+        composite_value_traits< value_type, id_sqlite >::image_type value_value;
+
+        std::size_t version;
+      };
+
+      static void
+      bind (sqlite::bind*,
+            const sqlite::bind* id,
+            std::size_t id_size,
+            data_image_type&);
+
+      static void
+      grow (data_image_type&,
+            bool*);
+
+      static void
+      init (data_image_type&,
+            index_type*,
+            const value_type&);
+
+      static void
+      init (index_type&,
+            value_type&,
+            const data_image_type&,
+            database*);
+
+      static void
+      insert (index_type, const value_type&, void*);
+
+      static bool
+      select (index_type&, value_type&, void*);
+
+      static void
+      delete_ (void*);
+
+      static void
+      persist (const container_type&,
+               statements_type&);
+
+      static void
+      load (container_type&,
+            statements_type&);
+
+      static void
+      update (const container_type&,
+              statements_type&);
+
+      static void
+      erase (statements_type&);
+    };
+
+    // dependency_alternatives_section
+    //
+    struct dependency_alternatives_section_traits
+    {
+      typedef object_traits_impl<object_type, id_sqlite>::image_type image_type;
+      typedef object_traits_impl<object_type, id_sqlite>::id_image_type id_image_type;
+
+      static const std::size_t id_column_count = 1UL;
+      static const std::size_t managed_optimistic_load_column_count = 0UL;
+      static const std::size_t load_column_count = 0UL;
+      static const std::size_t managed_optimistic_update_column_count = 0UL;
+      static const std::size_t update_column_count = 0UL;
+
+      static const bool versioned = false;
+
+      static void
+      load (extra_statement_cache_type&, object_type&);
+
+      static void
+      update (extra_statement_cache_type&, const object_type&);
+    };
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static void
+    bind (sqlite::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef sqlite::object_statements<object_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+
+    static const std::size_t column_count = 22UL;
+    static const std::size_t id_column_count = 1UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static bool
+    load (connection&, object_type&, section&);
+
+    static bool
+    update (connection&, const object_type&, const section&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::selected_package, id_common >:
+    public access::object_traits_impl< ::bpkg::selected_package, id_sqlite >
+  {
+  };
+
+  // certificate
+  //
+  template <typename A>
+  struct query_columns< ::bpkg::certificate, id_sqlite, A >
+  {
+    // id
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    id_type_;
+
+    static const id_type_ id;
+
+    // fingerprint
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    fingerprint_type_;
+
+    static const fingerprint_type_ fingerprint;
+
+    // name
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    name_type_;
+
+    static const name_type_ name;
+
+    // organization
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    organization_type_;
+
+    static const organization_type_ organization;
+
+    // email
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::std::string,
+        sqlite::id_text >::query_type,
+      sqlite::id_text >
+    email_type_;
+
+    static const email_type_ email;
+
+    // start_date
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::uint64_t,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    start_date_type_;
+
+    static const start_date_type_ start_date;
+
+    // end_date
+    //
+    typedef
+    sqlite::query_column<
+      sqlite::value_traits<
+        ::uint64_t,
+        sqlite::id_integer >::query_type,
+      sqlite::id_integer >
+    end_date_type_;
+
+    static const end_date_type_ end_date;
+  };
+
+  template <typename A>
+  const typename query_columns< ::bpkg::certificate, id_sqlite, A >::id_type_
+  query_columns< ::bpkg::certificate, id_sqlite, A >::
+  id (A::table_name, "\"id\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::certificate, id_sqlite, A >::fingerprint_type_
+  query_columns< ::bpkg::certificate, id_sqlite, A >::
+  fingerprint (A::table_name, "\"fingerprint\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::certificate, id_sqlite, A >::name_type_
+  query_columns< ::bpkg::certificate, id_sqlite, A >::
+  name (A::table_name, "\"name\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::certificate, id_sqlite, A >::organization_type_
+  query_columns< ::bpkg::certificate, id_sqlite, A >::
+  organization (A::table_name, "\"organization\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::certificate, id_sqlite, A >::email_type_
+  query_columns< ::bpkg::certificate, id_sqlite, A >::
+  email (A::table_name, "\"email\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::certificate, id_sqlite, A >::start_date_type_
+  query_columns< ::bpkg::certificate, id_sqlite, A >::
+  start_date (A::table_name, "\"start_date\"", 0);
+
+  template <typename A>
+  const typename query_columns< ::bpkg::certificate, id_sqlite, A >::end_date_type_
+  query_columns< ::bpkg::certificate, id_sqlite, A >::
+  end_date (A::table_name, "\"end_date\"", 0);
+
+  template <typename A>
+  struct pointer_query_columns< ::bpkg::certificate, id_sqlite, A >:
+    query_columns< ::bpkg::certificate, id_sqlite, A >
+  {
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::certificate, id_sqlite >:
+    public access::object_traits< ::bpkg::certificate >
+  {
+    public:
+    struct id_image_type
+    {
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      std::size_t version;
+    };
+
+    struct image_type
+    {
+      // id
+      //
+      details::buffer id_value;
+      std::size_t id_size;
+      bool id_null;
+
+      // fingerprint
+      //
+      details::buffer fingerprint_value;
+      std::size_t fingerprint_size;
+      bool fingerprint_null;
+
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // organization
+      //
+      details::buffer organization_value;
+      std::size_t organization_size;
+      bool organization_null;
+
+      // email
+      //
+      details::buffer email_value;
+      std::size_t email_size;
+      bool email_null;
+
+      // start_date
+      //
+      long long start_date_value;
+      bool start_date_null;
+
+      // end_date
+      //
+      long long end_date_value;
+      bool end_date_null;
+
+      std::size_t version;
+    };
+
+    struct extra_statement_cache_type;
+
+    using object_traits<object_type>::id;
+
+    static id_type
+    id (const image_type&);
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&,
+          sqlite::statement_kind);
+
+    static void
+    bind (sqlite::bind*, id_image_type&);
+
+    static bool
+    init (image_type&,
+          const object_type&,
+          sqlite::statement_kind);
+
+    static void
+    init (object_type&,
+          const image_type&,
+          database*);
+
+    static void
+    init (id_image_type&, const id_type&);
+
+    typedef sqlite::object_statements<object_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+
+    static const std::size_t column_count = 7UL;
+    static const std::size_t id_column_count = 1UL;
+    static const std::size_t inverse_column_count = 0UL;
+    static const std::size_t readonly_column_count = 0UL;
+    static const std::size_t managed_optimistic_column_count = 0UL;
+
+    static const std::size_t separate_load_column_count = 0UL;
+    static const std::size_t separate_update_column_count = 0UL;
+
+    static const bool versioned = false;
+
+    static const char persist_statement[];
+    static const char find_statement[];
+    static const char update_statement[];
+    static const char erase_statement[];
+    static const char query_statement[];
+    static const char erase_query_statement[];
+
+    static const char table_name[];
+
+    static void
+    persist (database&, const object_type&);
+
+    static pointer_type
+    find (database&, const id_type&);
+
+    static bool
+    find (database&, const id_type&, object_type&);
+
+    static bool
+    reload (database&, object_type&);
+
+    static void
+    update (database&, const object_type&);
+
+    static void
+    erase (database&, const id_type&);
+
+    static void
+    erase (database&, const object_type&);
+
+    static result<object_type>
+    query (database&, const query_base_type&);
+
+    static unsigned long long
+    erase_query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+
+    public:
+    static bool
+    find_ (statements_type&,
+           const id_type*);
+
+    static void
+    load_ (statements_type&,
+           object_type&,
+           bool reload);
+  };
+
+  template <>
+  class access::object_traits_impl< ::bpkg::certificate, id_common >:
+    public access::object_traits_impl< ::bpkg::certificate, id_sqlite >
+  {
+  };
+
+  // package_dependent
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >:
+    public access::view_traits< ::bpkg::package_dependent >
+  {
+    public:
+    struct image_type
+    {
+      // name
+      //
+      details::buffer name_value;
+      std::size_t name_size;
+      bool name_null;
+
+      // constraint
+      //
+      composite_value_traits< ::bpkg::version_constraint, id_sqlite >::image_type constraint_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns
+    {
+    };
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 17UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::package_dependent, id_common >:
+    public access::view_traits_impl< ::bpkg::package_dependent, id_sqlite >
+  {
+  };
+
+  // fragment_repository_count
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >:
+    public access::view_traits< ::bpkg::fragment_repository_count >
+  {
+    public:
+    struct image_type
+    {
+      // result
+      //
+      long long result_value;
+      bool result_null;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns
+    {
+    };
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 1UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::fragment_repository_count, id_common >:
+    public access::view_traits_impl< ::bpkg::fragment_repository_count, id_sqlite >
+  {
+  };
+
+  // fragment_repository
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >:
+    public access::view_traits< ::bpkg::fragment_repository >
+  {
+    public:
+    struct image_type
+    {
+      // object
+      //
+      object_traits_impl< ::bpkg::repository, id_sqlite >::image_type object_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 5UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::fragment_repository, id_common >:
+    public access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >
+  {
+  };
+
+  // repository_complement_dependent
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >:
+    public access::view_traits< ::bpkg::repository_complement_dependent >
+  {
+    public:
+    struct image_type
+    {
+      // object
+      //
+      object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::image_type object_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    struct complement_tag;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 3UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_complement_dependent, id_common >:
+    public access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >
+  {
+  };
+
+  // repository_prerequisite_dependent
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >:
+    public access::view_traits< ::bpkg::repository_prerequisite_dependent >
+  {
+    public:
+    struct image_type
+    {
+      // object
+      //
+      object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::image_type object_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    struct prerequisite_tag;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 3UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_common >:
+    public access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >
+  {
+  };
+
+  // repository_fragment_package
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >:
+    public access::view_traits< ::bpkg::repository_fragment_package >
+  {
+    public:
+    struct image_type
+    {
+      // package
+      //
+      object_traits_impl< ::bpkg::available_package, id_sqlite >::image_type package_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    struct package_tag;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 15UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::repository_fragment_package, id_common >:
+    public access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >
+  {
+  };
+
+  // package_repository_fragment
+  //
+  template <>
+  class access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >:
+    public access::view_traits< ::bpkg::package_repository_fragment >
+  {
+    public:
+    struct image_type
+    {
+      // package_id
+      //
+      composite_value_traits< ::bpkg::available_package_id, id_sqlite >::image_type package_id_value;
+
+      // repository_fragment
+      //
+      object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::image_type repository_fragment_value;
+
+      std::size_t version;
+    };
+
+    typedef sqlite::view_statements<view_type> statements_type;
+
+    struct package_tag;
+
+    typedef sqlite::query_base query_base_type;
+    struct query_columns;
+
+    static const bool versioned = false;
+
+    static bool
+    grow (image_type&,
+          bool*);
+
+    static void
+    bind (sqlite::bind*,
+          image_type&);
+
+    static void
+    init (view_type&,
+          const image_type&,
+          database*);
+
+    static const std::size_t column_count = 9UL;
+
+    static query_base_type
+    query_statement (const query_base_type&);
+
+    static result<view_type>
+    query (database&, const query_base_type&);
+
+    static odb::details::shared_ptr<prepared_query_impl>
+    prepare_query (connection&, const char*, const query_base_type&);
+
+    static odb::details::shared_ptr<result_impl>
+    execute_query (prepared_query_impl&);
+  };
+
+  template <>
+  class access::view_traits_impl< ::bpkg::package_repository_fragment, id_common >:
+    public access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >
+  {
+  };
+
+  // configuration
+  //
+  // repository_fragment
+  //
+  // repository_fragment_count
+  //
+  struct access::view_traits_impl< ::bpkg::repository_fragment_count, id_sqlite >::query_columns:
+    odb::pointer_query_columns<
+      ::bpkg::repository_fragment,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite > >
+  {
+  };
+
+  // repository
+  //
+  // repository_count
+  //
+  struct access::view_traits_impl< ::bpkg::repository_count, id_sqlite >::query_columns:
+    odb::pointer_query_columns<
+      ::bpkg::repository,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository, id_sqlite > >
+  {
+  };
+
+  // available_package
+  //
+  // available_package_count
+  //
+  struct access::view_traits_impl< ::bpkg::available_package_count, id_sqlite >::query_columns:
+    odb::pointer_query_columns<
+      ::bpkg::available_package,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::available_package, id_sqlite > >
+  {
+  };
+
+  // available_test
+  //
+  template <>
+  struct alias_traits<
+    ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::available_test, id_sqlite >::package_tag>
+  {
+    static const char table_name[];
+  };
+
+  struct access::view_traits_impl< ::bpkg::available_test, id_sqlite >::query_columns:
+    odb::pointer_query_columns<
+      ::bpkg::available_package,
+      id_sqlite,
+      odb::alias_traits<
+        ::bpkg::available_package,
+        id_sqlite,
+        access::view_traits_impl< ::bpkg::available_test, id_sqlite >::package_tag> >
+  {
+  };
+
+  // available_main
+  //
+  template <>
+  struct alias_traits<
+    ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::available_main, id_sqlite >::package_tag>
+  {
+    static const char table_name[];
+  };
+
+  struct access::view_traits_impl< ::bpkg::available_main, id_sqlite >::query_columns:
+    odb::pointer_query_columns<
+      ::bpkg::available_package,
+      id_sqlite,
+      odb::alias_traits<
+        ::bpkg::available_package,
+        id_sqlite,
+        access::view_traits_impl< ::bpkg::available_main, id_sqlite >::package_tag> >
+  {
+  };
+
+  // selected_package
+  //
+  // certificate
+  //
+  // fragment_repository
+  //
+  struct access::view_traits_impl< ::bpkg::fragment_repository, id_sqlite >::query_columns
+  {
+    // repository
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository, id_sqlite > >
+    repository;
+
+    // repository_fragment
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository_fragment,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite > >
+    repository_fragment;
+  };
+
+  // repository_complement_dependent
+  //
+  template <>
+  struct alias_traits<
+    ::bpkg::repository,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::complement_tag>
+  {
+    static const char table_name[];
+  };
+
+  struct access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::query_columns
+  {
+    // complement
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository,
+      id_sqlite,
+      odb::alias_traits< ::bpkg::repository,
+        id_sqlite,
+        access::view_traits_impl< ::bpkg::repository_complement_dependent, id_sqlite >::complement_tag> >
+    complement;
+
+    // repository_fragment
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository_fragment,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite > >
+    repository_fragment;
+  };
+
+  // repository_prerequisite_dependent
+  //
+  template <>
+  struct alias_traits<
+    ::bpkg::repository,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::prerequisite_tag>
+  {
+    static const char table_name[];
+  };
+
+  struct access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::query_columns
+  {
+    // prerequisite
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository,
+      id_sqlite,
+      odb::alias_traits< ::bpkg::repository,
+        id_sqlite,
+        access::view_traits_impl< ::bpkg::repository_prerequisite_dependent, id_sqlite >::prerequisite_tag> >
+    prerequisite;
+
+    // repository_fragment
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository_fragment,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite > >
+    repository_fragment;
+  };
+
+  // repository_fragment_package
+  //
+  template <>
+  struct alias_traits<
+    ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::package_tag>
+  {
+    static const char table_name[];
+  };
+
+  struct access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::query_columns
+  {
+    // repository_fragment
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository_fragment,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite > >
+    repository_fragment;
+
+    // package
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::available_package,
+      id_sqlite,
+      odb::alias_traits< ::bpkg::available_package,
+        id_sqlite,
+        access::view_traits_impl< ::bpkg::repository_fragment_package, id_sqlite >::package_tag> >
+    package;
+  };
+
+  // package_repository_fragment
+  //
+  template <>
+  struct alias_traits<
+    ::bpkg::available_package,
+    id_sqlite,
+    access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::package_tag>
+  {
+    static const char table_name[];
+  };
+
+  struct access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::query_columns
+  {
+    // repository_fragment
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::repository_fragment,
+      id_sqlite,
+      odb::access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite > >
+    repository_fragment;
+
+    // package
+    //
+    typedef
+    odb::pointer_query_columns<
+      ::bpkg::available_package,
+      id_sqlite,
+      odb::alias_traits< ::bpkg::available_package,
+        id_sqlite,
+        access::view_traits_impl< ::bpkg::package_repository_fragment, id_sqlite >::package_tag> >
+    package;
+  };
+}
+
+#include <bpkg/package-odb.ixx>
+
+#include <odb/post.hxx>
+
+#endif // BPKG_PACKAGE_ODB_HXX
diff --git a/bpkg/package-odb.ixx b/bpkg/package-odb.ixx
new file mode 100644
index 0000000..a831734
--- /dev/null
+++ b/bpkg/package-odb.ixx
@@ -0,0 +1,1038 @@
+// -*- C++ -*-
+//
+// This file was generated by ODB, object-relational mapping (ORM)
+// compiler for C++.
+//
+
+namespace odb
+{
+  // configuration
+  //
+
+  inline
+  access::object_traits< ::bpkg::configuration >::id_type
+  access::object_traits< ::bpkg::configuration >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::bpkg::configuration >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::bpkg::configuration >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository_fragment
+  //
+
+  inline
+  access::object_traits< ::bpkg::repository_fragment >::id_type
+  access::object_traits< ::bpkg::repository_fragment >::
+  id (const object_type& o)
+  {
+    return o.name;
+  }
+
+  inline
+  void access::object_traits< ::bpkg::repository_fragment >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::bpkg::repository_fragment >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository_fragment_count
+  //
+
+  inline
+  void access::view_traits< ::bpkg::repository_fragment_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository
+  //
+
+  inline
+  access::object_traits< ::bpkg::repository >::id_type
+  access::object_traits< ::bpkg::repository >::
+  id (const object_type& o)
+  {
+    return o.name;
+  }
+
+  inline
+  void access::object_traits< ::bpkg::repository >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::bpkg::repository >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository_count
+  //
+
+  inline
+  void access::view_traits< ::bpkg::repository_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // available_package
+  //
+
+  inline
+  access::object_traits< ::bpkg::available_package >::id_type
+  access::object_traits< ::bpkg::available_package >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::bpkg::available_package >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::bpkg::available_package >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // available_package_count
+  //
+
+  inline
+  void access::view_traits< ::bpkg::available_package_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // available_test
+  //
+
+  inline
+  void access::view_traits< ::bpkg::available_test >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // available_main
+  //
+
+  inline
+  void access::view_traits< ::bpkg::available_main >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // selected_package
+  //
+
+  inline
+  access::object_traits< ::bpkg::selected_package >::id_type
+  access::object_traits< ::bpkg::selected_package >::
+  id (const object_type& o)
+  {
+    return o.name;
+  }
+
+  inline
+  void access::object_traits< ::bpkg::selected_package >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::bpkg::selected_package >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // certificate
+  //
+
+  inline
+  access::object_traits< ::bpkg::certificate >::id_type
+  access::object_traits< ::bpkg::certificate >::
+  id (const object_type& o)
+  {
+    return o.id;
+  }
+
+  inline
+  void access::object_traits< ::bpkg::certificate >::
+  callback (database& db, object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  inline
+  void access::object_traits< ::bpkg::certificate >::
+  callback (database& db, const object_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // package_dependent
+  //
+
+  inline
+  void access::view_traits< ::bpkg::package_dependent >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // fragment_repository_count
+  //
+
+  inline
+  void access::view_traits< ::bpkg::fragment_repository_count >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // fragment_repository
+  //
+
+  inline
+  void access::view_traits< ::bpkg::fragment_repository >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository_complement_dependent
+  //
+
+  inline
+  void access::view_traits< ::bpkg::repository_complement_dependent >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository_prerequisite_dependent
+  //
+
+  inline
+  void access::view_traits< ::bpkg::repository_prerequisite_dependent >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // repository_fragment_package
+  //
+
+  inline
+  void access::view_traits< ::bpkg::repository_fragment_package >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+
+  // package_repository_fragment
+  //
+
+  inline
+  void access::view_traits< ::bpkg::package_repository_fragment >::
+  callback (database& db, view_type& x, callback_event e)
+  {
+    ODB_POTENTIALLY_UNUSED (db);
+    ODB_POTENTIALLY_UNUSED (x);
+    ODB_POTENTIALLY_UNUSED (e);
+  }
+}
+
+#include <odb/schema-version.hxx>
+
+namespace odb
+{
+  // _version
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::_version, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.epoch_null;
+    r = r && i.canonical_upstream_null;
+    r = r && i.canonical_release_null;
+    r = r && i.revision_null;
+    r = r && i.iteration_null;
+    r = r && i.upstream_null;
+    r = r && i.release_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::_version, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.epoch_null = true;
+    i.canonical_upstream_null = true;
+    i.canonical_release_null = true;
+    i.revision_null = true;
+    i.iteration_null = true;
+    i.upstream_null = true;
+    i.release_null = true;
+  }
+
+  // language
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::language, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.name_null;
+    r = r && i.impl_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::language, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.name_null = true;
+    i.impl_null = true;
+  }
+
+  // version_constraint
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::version_constraint, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && composite_value_traits< ::bpkg::_version, id_sqlite >::get_null (i.min_version_value);
+    r = r && composite_value_traits< ::bpkg::_version, id_sqlite >::get_null (i.max_version_value);
+    r = r && i.min_open_null;
+    r = r && i.max_open_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::version_constraint, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    composite_value_traits< ::bpkg::_version, id_sqlite >::set_null (i.min_version_value, sk);
+    composite_value_traits< ::bpkg::_version, id_sqlite >::set_null (i.max_version_value, sk);
+    i.min_open_null = true;
+    i.max_open_null = true;
+  }
+
+  // dependency
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::dependency, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.name_null;
+    r = r && composite_value_traits< ::bpkg::version_constraint, id_sqlite >::get_null (i.constraint_value);
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::dependency, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.name_null = true;
+    composite_value_traits< ::bpkg::version_constraint, id_sqlite >::set_null (i.constraint_value, sk);
+  }
+
+  // dependency_alternative
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::dependency_alternative, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.enable_null;
+    r = r && i.reflect_null;
+    r = r && i.prefer_null;
+    r = r && i.accept_null;
+    r = r && i.require_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::dependency_alternative, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.enable_null = true;
+    i.reflect_null = true;
+    i.prefer_null = true;
+    i.accept_null = true;
+    i.require_null = true;
+  }
+
+  // dependency_alternatives
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.buildtime_null;
+    r = r && i.comment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.buildtime_null = true;
+    i.comment_null = true;
+  }
+
+  // test_dependency
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::test_dependency, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && composite_value_traits< ::bpkg::dependency, id_sqlite >::get_null (i);
+    r = r && i.type_null;
+    r = r && i.buildtime_null;
+    r = r && i.enable_null;
+    r = r && i.reflect_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::test_dependency, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    composite_value_traits< ::bpkg::dependency, id_sqlite >::set_null (i, sk);
+    i.type_null = true;
+    i.buildtime_null = true;
+    i.enable_null = true;
+    i.reflect_null = true;
+  }
+
+  // buildfile
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::buildfile, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.path_null;
+    r = r && i.content_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::buildfile, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.path_null = true;
+    i.content_null = true;
+  }
+
+  // distribution_name_value
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::distribution_name_value, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.name_null;
+    r = r && i.value_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::distribution_name_value, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.name_null = true;
+    i.value_null = true;
+  }
+
+  // configuration
+  //
+
+  inline
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  inline
+  void access::object_traits_impl< ::bpkg::configuration, id_sqlite >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool)
+  {
+    ODB_POTENTIALLY_UNUSED (sts);
+    ODB_POTENTIALLY_UNUSED (obj);
+  }
+
+  // canonical_version
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::canonical_version, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.epoch_null;
+    r = r && i.canonical_upstream_null;
+    r = r && i.canonical_release_null;
+    r = r && i.revision_null;
+    r = r && i.iteration_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::canonical_version, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.epoch_null = true;
+    i.canonical_upstream_null = true;
+    i.canonical_release_null = true;
+    i.revision_null = true;
+    i.iteration_null = true;
+  }
+
+  // upstream_version
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::upstream_version, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.upstream_null;
+    r = r && i.release_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::upstream_version, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.upstream_null = true;
+    i.release_null = true;
+  }
+
+  // _repository_location
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::_repository_location, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.url_null;
+    r = r && i.type_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::_repository_location, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.url_null = true;
+    i.type_null = true;
+  }
+
+  // repository_fragment
+  //
+
+  inline
+  void access::object_traits_impl< ::bpkg::repository_fragment, id_sqlite >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // repository_fragment_count
+  //
+
+  // fragment_type
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::repository::fragment_type, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.friendly_name_null;
+    r = r && i.fragment_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::repository::fragment_type, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.friendly_name_null = true;
+    i.fragment_null = true;
+  }
+
+  // repository
+  //
+
+  inline
+  void access::object_traits_impl< ::bpkg::repository, id_sqlite >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // repository_count
+  //
+
+  // package_location
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::package_location, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.repository_fragment_null;
+    r = r && i.location_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::package_location, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.repository_fragment_null = true;
+    i.location_null = true;
+  }
+
+  // dependency_alternatives_ex
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::dependency_alternatives_ex, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::get_null (i);
+    r = r && i.type_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::dependency_alternatives_ex, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    composite_value_traits< ::bpkg::dependency_alternatives, id_sqlite >::set_null (i, sk);
+    i.type_null = true;
+  }
+
+  // available_package_id
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::available_package_id, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.name_null;
+    r = r && composite_value_traits< ::bpkg::canonical_version, id_sqlite >::get_null (i.version_value);
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::available_package_id, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.name_null = true;
+    composite_value_traits< ::bpkg::canonical_version, id_sqlite >::set_null (i.version_value, sk);
+  }
+
+  // _dependency_alternative_key
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::available_package::_dependency_alternative_key, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.outer_null;
+    r = r && i.inner_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::available_package::_dependency_alternative_key, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.outer_null = true;
+    i.inner_null = true;
+  }
+
+  // _dependency_key
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::available_package::_dependency_key, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.outer_null;
+    r = r && i.middle_null;
+    r = r && i.inner_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::available_package::_dependency_key, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.outer_null = true;
+    i.middle_null = true;
+    i.inner_null = true;
+  }
+
+  // available_package
+  //
+
+  inline
+  void access::object_traits_impl< ::bpkg::available_package, id_sqlite >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // available_package_count
+  //
+
+  // available_test
+  //
+
+  // available_main
+  //
+
+  // prerequisite_info
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::prerequisite_info, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && composite_value_traits< ::bpkg::version_constraint, id_sqlite >::get_null (i.constraint_value);
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::prerequisite_info, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    composite_value_traits< ::bpkg::version_constraint, id_sqlite >::set_null (i.constraint_value, sk);
+  }
+
+  // _selected_package_ref
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.configuration_null;
+    r = r && i.prerequisite_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::_selected_package_ref, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.configuration_null = true;
+    i.prerequisite_null = true;
+  }
+
+  // config_variable
+  //
+
+  inline
+  bool access::composite_value_traits< ::bpkg::config_variable, id_sqlite >::
+  get_null (const image_type& i)
+  {
+    bool r (true);
+    r = r && i.name_null;
+    r = r && i.source_null;
+    return r;
+  }
+
+  inline
+  void access::composite_value_traits< ::bpkg::config_variable, id_sqlite >::
+  set_null (image_type& i,
+            sqlite::statement_kind sk)
+  {
+    ODB_POTENTIALLY_UNUSED (sk);
+
+    using namespace sqlite;
+
+    i.name_null = true;
+    i.source_null = true;
+  }
+
+  // selected_package
+  //
+
+  inline
+  void access::object_traits_impl< ::bpkg::selected_package, id_sqlite >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  // certificate
+  //
+
+  inline
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  erase (database& db, const object_type& obj)
+  {
+    callback (db, obj, callback_event::pre_erase);
+    erase (db, id (obj));
+    callback (db, obj, callback_event::post_erase);
+  }
+
+  inline
+  void access::object_traits_impl< ::bpkg::certificate, id_sqlite >::
+  load_ (statements_type& sts,
+         object_type& obj,
+         bool)
+  {
+    ODB_POTENTIALLY_UNUSED (sts);
+    ODB_POTENTIALLY_UNUSED (obj);
+  }
+
+  // package_dependent
+  //
+
+  // fragment_repository_count
+  //
+
+  // fragment_repository
+  //
+
+  // repository_complement_dependent
+  //
+
+  // repository_prerequisite_dependent
+  //
+
+  // repository_fragment_package
+  //
+
+  // package_repository_fragment
+  //
+}
+
diff --git a/bpkg/pkg-bindist-options.cxx b/bpkg/pkg-bindist-options.cxx
new file mode 100644
index 0000000..cceb8b7
--- /dev/null
+++ b/bpkg/pkg-bindist-options.cxx
@@ -0,0 +1,3081 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-bindist-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_bindist_common_options
+  //
+
+  pkg_bindist_common_options::
+  pkg_bindist_common_options ()
+  : distribution_ (),
+    distribution_specified_ (false),
+    architecture_ (),
+    architecture_specified_ (false),
+    recursive_ ("none"),
+    recursive_specified_ (false),
+    private__ (),
+    output_root_ (),
+    output_root_specified_ (false),
+    wipe_output_ (),
+    keep_output_ (),
+    allow_dependent_config_ (),
+    os_release_id_ (),
+    os_release_id_specified_ (false),
+    os_release_version_id_ (),
+    os_release_version_id_specified_ (false),
+    os_release_name_ (),
+    os_release_name_specified_ (false)
+  {
+  }
+
+  bool pkg_bindist_common_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_common_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_common_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_common_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_common_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_bindist_common_options::
+  merge (const pkg_bindist_common_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.distribution_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->distribution_, a.distribution_);
+      this->distribution_specified_ = true;
+    }
+
+    if (a.architecture_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->architecture_, a.architecture_);
+      this->architecture_specified_ = true;
+    }
+
+    if (a.recursive_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->recursive_, a.recursive_);
+      this->recursive_specified_ = true;
+    }
+
+    if (a.private__)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->private__, a.private__);
+    }
+
+    if (a.output_root_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->output_root_, a.output_root_);
+      this->output_root_specified_ = true;
+    }
+
+    if (a.wipe_output_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->wipe_output_, a.wipe_output_);
+    }
+
+    if (a.keep_output_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_output_, a.keep_output_);
+    }
+
+    if (a.allow_dependent_config_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->allow_dependent_config_, a.allow_dependent_config_);
+    }
+
+    if (a.os_release_id_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->os_release_id_, a.os_release_id_);
+      this->os_release_id_specified_ = true;
+    }
+
+    if (a.os_release_version_id_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->os_release_version_id_, a.os_release_version_id_);
+      this->os_release_version_id_specified_ = true;
+    }
+
+    if (a.os_release_name_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->os_release_name_, a.os_release_name_);
+      this->os_release_name_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_bindist_common_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-BINDIST OPTIONS\033[0m" << ::std::endl
+       << ::std::endl
+       << "See the following sections below for distribution-specific options:" << ::std::endl
+       << ::std::endl
+       << "PKG-BINDIST DEBIAN OPTIONS" << ::std::endl
+       << ::std::endl
+       << "PKG-BINDIST FEDORA OPTIONS" << ::std::endl
+       << ::std::endl
+       << "PKG-BINDIST ARCHIVE OPTIONS" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--distribution\033[0m \033[4mname\033[0m       Alternative system/distribution package manager to" << ::std::endl
+       << "                          generate the binary package for. The valid \033[4mname\033[0m" << ::std::endl
+       << "                          values are \033[1mdebian\033[0m (Debian and alike, such as Ubuntu," << ::std::endl
+       << "                          etc), \033[1mfedora\033[0m (Fedora and alike, such as RHEL, CentOS," << ::std::endl
+       << "                          etc), and \033[1marchive\033[0m (installation archive on any" << ::std::endl
+       << "                          operating system). Note that some package managers" << ::std::endl
+       << "                          may only be supported when running on certain host" << ::std::endl
+       << "                          operating systems." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--architecture\033[0m \033[4mname\033[0m       Alternative architecture to generate the binary" << ::std::endl
+       << "                          package for. The valid \033[4mname\033[0m values are" << ::std::endl
+       << "                          system/distribution package manager-specific. If" << ::std::endl
+       << "                          unspecified, the host architecture is used." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m \033[4mmode\033[0m          Bundle or generate dependencies of the specified" << ::std::endl
+       << "                          packages. The \033[4mmode\033[0m value can be either \033[1mauto\033[0m, in which" << ::std::endl
+       << "                          case only the required files from each dependency" << ::std::endl
+       << "                          package are bundled, \033[1mfull\033[0m, in which case all the" << ::std::endl
+       << "                          files are bundled, or \033[1mseparate\033[0m, in which case a" << ::std::endl
+       << "                          separate binary package is generated for each" << ::std::endl
+       << "                          non-system dependency. It can also be \033[1mnone\033[0m which is" << ::std::endl
+       << "                          equivalent to not specifying this option (primarily" << ::std::endl
+       << "                          useful for overriding a previously-specified value)." << ::std::endl
+       << ::std::endl
+       << "                          Specifically, in the \033[1mauto\033[0m mode any required files," << ::std::endl
+       << "                          such as shared libraries, are pulled implicitly by" << ::std::endl
+       << "                          the \033[1minstall\033[0m build system operation, for example, as" << ::std::endl
+       << "                          part of installing an executable from one of the" << ::std::endl
+       << "                          specified packages. In contrast, in the \033[1mfull\033[0m mode," << ::std::endl
+       << "                          each dependency package is installed explicitly and" << ::std::endl
+       << "                          completely, as if they were specified as additional" << ::std::endl
+       << "                          package on the command line. The \033[1mseparate\033[0m mode is" << ::std::endl
+       << "                          equivalent to invoking the \033[1mpkg-bindist\033[0m command on" << ::std::endl
+       << "                          each dependency package. See also the \033[1m--private\033[0m" << ::std::endl
+       << "                          option." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--private\033[0m                 Enable the private installation subdirectory" << ::std::endl
+       << "                          functionality using the package name as the private" << ::std::endl
+       << "                          subdirectory. This is primarily useful when bundling" << ::std::endl
+       << "                          dependencies, such as shared libraries, of an" << ::std::endl
+       << "                          executable that is being installed into a shared" << ::std::endl
+       << "                          location, such as \033[1m/usr/\033[0m.  See the" << ::std::endl
+       << "                          \033[1mconfig.install.private\033[0m configuration variable" << ::std::endl
+       << "                          documentation in the build system manual for details." << ::std::endl
+       << "                          This option only makes sense together with the" << ::std::endl
+       << "                          \033[1m--recursive\033[0m option \033[1mauto\033[0m and \033[1mfull\033[0m modes." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--output-root\033[0m|\033[1m-o\033[0m \033[4mdir\033[0m      Directory for intermediate files and subdirectories" << ::std::endl
+       << "                          as well as the resulting binary package. Note that" << ::std::endl
+       << "                          this option may be required for some system package" << ::std::endl
+       << "                          managers and may not be specified for others." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--wipe-output\033[0m             Wipe the output root directory (either specified with" << ::std::endl
+       << "                          \033[4m--output-root\033[0m or system package manager-specific)" << ::std::endl
+       << "                          clean before using it to generate the binary package." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-output\033[0m             Keep intermediate files in the output root directory" << ::std::endl
+       << "                          (either specified with \033[4m--output-root\033[0m or system" << ::std::endl
+       << "                          package manager-specific) that were used to generate" << ::std::endl
+       << "                          the binary package. This is primarily useful for" << ::std::endl
+       << "                          troubleshooting." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--allow-dependent-config\033[0m  Allow configuration that is imposed by dependent" << ::std::endl
+       << "                          packages. Normally this is undesirable because the" << ::std::endl
+       << "                          resulting binary packages become configured" << ::std::endl
+       << "                          specificaly for particular dependent packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--os-release-id\033[0m \033[4mv\033[0m         Override the \033[1mID\033[0m component in \033[1mos-release(5)\033[0m or" << ::std::endl
+       << "                          equivalent. Note that unlike the rest of the" << ::std::endl
+       << "                          \033[1m--os-release-*\033[0m options, this option suppresses" << ::std::endl
+       << "                          automatic detection of the host operating system" << ::std::endl
+       << "                          information." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--os-release-version-id\033[0m \033[4mv\033[0m Override the \033[1mVERSION_ID\033[0m component in \033[1mos-release(5)\033[0m or" << ::std::endl
+       << "                          equivalent." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--os-release-name\033[0m \033[4mv\033[0m       Override the \033[1mNAME\033[0m component in \033[1mos-release(5)\033[0m or" << ::std::endl
+       << "                          equivalent." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_bindist_common_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_bindist_common_options_map;
+
+  static _cli_pkg_bindist_common_options_map _cli_pkg_bindist_common_options_map_;
+
+  struct _cli_pkg_bindist_common_options_map_init
+  {
+    _cli_pkg_bindist_common_options_map_init ()
+    {
+      _cli_pkg_bindist_common_options_map_["--distribution"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, string, &pkg_bindist_common_options::distribution_,
+        &pkg_bindist_common_options::distribution_specified_ >;
+      _cli_pkg_bindist_common_options_map_["--architecture"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, string, &pkg_bindist_common_options::architecture_,
+        &pkg_bindist_common_options::architecture_specified_ >;
+      _cli_pkg_bindist_common_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, string, &pkg_bindist_common_options::recursive_,
+        &pkg_bindist_common_options::recursive_specified_ >;
+      _cli_pkg_bindist_common_options_map_["--private"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, &pkg_bindist_common_options::private__ >;
+      _cli_pkg_bindist_common_options_map_["--output-root"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, dir_path, &pkg_bindist_common_options::output_root_,
+        &pkg_bindist_common_options::output_root_specified_ >;
+      _cli_pkg_bindist_common_options_map_["-o"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, dir_path, &pkg_bindist_common_options::output_root_,
+        &pkg_bindist_common_options::output_root_specified_ >;
+      _cli_pkg_bindist_common_options_map_["--wipe-output"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, &pkg_bindist_common_options::wipe_output_ >;
+      _cli_pkg_bindist_common_options_map_["--keep-output"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, &pkg_bindist_common_options::keep_output_ >;
+      _cli_pkg_bindist_common_options_map_["--allow-dependent-config"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, &pkg_bindist_common_options::allow_dependent_config_ >;
+      _cli_pkg_bindist_common_options_map_["--os-release-id"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, string, &pkg_bindist_common_options::os_release_id_,
+        &pkg_bindist_common_options::os_release_id_specified_ >;
+      _cli_pkg_bindist_common_options_map_["--os-release-version-id"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, string, &pkg_bindist_common_options::os_release_version_id_,
+        &pkg_bindist_common_options::os_release_version_id_specified_ >;
+      _cli_pkg_bindist_common_options_map_["--os-release-name"] =
+      &::bpkg::cli::thunk< pkg_bindist_common_options, string, &pkg_bindist_common_options::os_release_name_,
+        &pkg_bindist_common_options::os_release_name_specified_ >;
+    }
+  };
+
+  static _cli_pkg_bindist_common_options_map_init _cli_pkg_bindist_common_options_map_init_;
+
+  bool pkg_bindist_common_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_bindist_common_options_map::const_iterator i (_cli_pkg_bindist_common_options_map_.find (o));
+
+    if (i != _cli_pkg_bindist_common_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_bindist_common_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // pkg_bindist_debian_options
+  //
+
+  pkg_bindist_debian_options::
+  pkg_bindist_debian_options ()
+  : debian_prepare_only_ (),
+    debian_buildflags_ ("assign"),
+    debian_buildflags_specified_ (false),
+    debian_maint_option_ (),
+    debian_maint_option_specified_ (false),
+    debian_build_option_ (),
+    debian_build_option_specified_ (false),
+    debian_build_meta_ (),
+    debian_build_meta_specified_ (false),
+    debian_section_ (),
+    debian_section_specified_ (false),
+    debian_priority_ (),
+    debian_priority_specified_ (false),
+    debian_maintainer_ (),
+    debian_maintainer_specified_ (false),
+    debian_architecture_ (),
+    debian_architecture_specified_ (false),
+    debian_main_langdep_ (),
+    debian_main_langdep_specified_ (false),
+    debian_dev_langdep_ (),
+    debian_dev_langdep_specified_ (false),
+    debian_main_extradep_ (),
+    debian_main_extradep_specified_ (false),
+    debian_dev_extradep_ (),
+    debian_dev_extradep_specified_ (false)
+  {
+  }
+
+  bool pkg_bindist_debian_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_debian_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_debian_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_debian_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_debian_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_bindist_debian_options::
+  merge (const pkg_bindist_debian_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    if (a.debian_prepare_only_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->debian_prepare_only_, a.debian_prepare_only_);
+    }
+
+    if (a.debian_buildflags_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_buildflags_, a.debian_buildflags_);
+      this->debian_buildflags_specified_ = true;
+    }
+
+    if (a.debian_maint_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->debian_maint_option_, a.debian_maint_option_);
+      this->debian_maint_option_specified_ = true;
+    }
+
+    if (a.debian_build_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->debian_build_option_, a.debian_build_option_);
+      this->debian_build_option_specified_ = true;
+    }
+
+    if (a.debian_build_meta_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_build_meta_, a.debian_build_meta_);
+      this->debian_build_meta_specified_ = true;
+    }
+
+    if (a.debian_section_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_section_, a.debian_section_);
+      this->debian_section_specified_ = true;
+    }
+
+    if (a.debian_priority_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_priority_, a.debian_priority_);
+      this->debian_priority_specified_ = true;
+    }
+
+    if (a.debian_maintainer_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_maintainer_, a.debian_maintainer_);
+      this->debian_maintainer_specified_ = true;
+    }
+
+    if (a.debian_architecture_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_architecture_, a.debian_architecture_);
+      this->debian_architecture_specified_ = true;
+    }
+
+    if (a.debian_main_langdep_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_main_langdep_, a.debian_main_langdep_);
+      this->debian_main_langdep_specified_ = true;
+    }
+
+    if (a.debian_dev_langdep_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_dev_langdep_, a.debian_dev_langdep_);
+      this->debian_dev_langdep_specified_ = true;
+    }
+
+    if (a.debian_main_extradep_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_main_extradep_, a.debian_main_extradep_);
+      this->debian_main_extradep_specified_ = true;
+    }
+
+    if (a.debian_dev_extradep_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->debian_dev_extradep_, a.debian_dev_extradep_);
+      this->debian_dev_extradep_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_bindist_debian_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEBIAN DESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The Debian binary packages are generated by producing the standard" << ::std::endl
+       << "\033[1mdebian/control\033[0m, \033[1mdebian/rules\033[0m, and other package metadata files and then" << ::std::endl
+       << "invoking \033[1mdpkg-buildpackage(1)\033[0m to build the binary package from that. In" << ::std::endl
+       << "particular, the \033[1mdebian/rules\033[0m implemenation is based on the \033[1mdh(1)\033[0m command" << ::std::endl
+       << "sequencer. While this approach is normally used to build packages from source," << ::std::endl
+       << "this implementation \"pretends\" that this is what's happening by overriding a" << ::std::endl
+       << "number of \033[1mdh\033[0m targets to invoke the \033[1mbuild2\033[0m build system on the required packages" << ::std::endl
+       << "directly in their \033[1mbpkg\033[0m configuration locations." << ::std::endl
+       << ::std::endl
+       << "The \033[1mdpkg-dev\033[0m (or \033[1mbuild-essential\033[0m) and \033[1mdebhelper\033[0m Debian packages must be" << ::std::endl
+       << "installed before invocation. Typical invocation:" << ::std::endl
+       << ::std::endl
+       << "bpkg build libhello" << ::std::endl
+       << "bpkg test libhello" << ::std::endl
+       << "bpkg bindist -o /tmp/output/ libhello" << ::std::endl
+       << ::std::endl
+       << "Unless the \033[1m--recursive\033[0m option \033[1mauto\033[0m or \033[1mfull\033[0m modes are specified, dependencies of" << ::std::endl
+       << "the specified package are translated to dependencies in the resulting binary" << ::std::endl
+       << "package using names and versions that refer to packages that would be generated" << ::std::endl
+       << "by the \033[1mpkg-bindist\033[0m command (called \"non-native\" packages). If instead you would" << ::std::endl
+       << "like certain dependencies to refer to binary packages provided by the" << ::std::endl
+       << "distribution (called \"native\" packages), then you need to arrange for them to" << ::std::endl
+       << "be built as system (see \033[1mbpkg-pkg-build(1)\033[0m for details). For example, if our" << ::std::endl
+       << "\033[1mlibhello\033[0m has a dependency on \033[1mlibsqlite3\033[0m and we would like the binary package" << ::std::endl
+       << "for \033[1mlibhello\033[0m to refer to \033[1mlibsqlite3\033[0m from Debian (or alike), then the \033[1mpkg-build\033[0m" << ::std::endl
+       << "command would need to be (\033[1m--sys-install\033[0m is optional):" << ::std::endl
+       << ::std::endl
+       << "bpkg build --sys-install libhello ?sys:libsqlite3" << ::std::endl
+       << ::std::endl
+       << "Such a package with native dependencies can then be installed (including any" << ::std::endl
+       << "missing native dependencies) using the \033[1mapt\033[0m or \033[1mapt-get\033[0m \033[1minstall\033[0m command. Note" << ::std::endl
+       << "that the specified \033[1m.deb\033[0m file must include a directory separator (/\033[0m) in order to" << ::std::endl
+       << "be recognized as a file rather than a package name. For example:" << ::std::endl
+       << ::std::endl
+       << "sudo apt-get install ./libhello_1.2.3-0~debian11_amd64.deb \\" << ::std::endl
+       << "                     ./libhello-dev_1.2.3-0~debian11_amd64.deb" << ::std::endl
+       << ::std::endl
+       << "See Debian Package Mapping for Production (bpkg#bindist-mapping-debian-produce)" << ::std::endl
+       << "for details on \033[1mbpkg\033[0m to Debian package name and version mapping." << ::std::endl;
+
+    os << std::endl
+       << "\033[1mPKG-BINDIST DEBIAN OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-prepare-only\033[0m     Prepare all the package metadata files (\033[1mcontrol\033[0m," << ::std::endl
+       << "                          \033[1mrules\033[0m, etc) but do not invoke \033[1mdpkg-buildpackage\033[0m to" << ::std::endl
+       << "                          generate the binary package, printing its command" << ::std::endl
+       << "                          line instead unless requested to be quiet. Implies" << ::std::endl
+       << "                          \033[1m--keep-output\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-buildflags\033[0m \033[4mmode\033[0m  Package build flags (\033[1mdpkg-buildflags\033[0m) usage mode." << ::std::endl
+       << "                          Valid \033[4mmode\033[0m values are \033[1massign\033[0m (use the build flags" << ::std::endl
+       << "                          instead of configured), \033[1mappend\033[0m (use the build flags" << ::std::endl
+       << "                          in addition to configured, putting them last)," << ::std::endl
+       << "                          \033[1mprepend\033[0m (use the build flags in addition to" << ::std::endl
+       << "                          configured, putting them first), and \033[1mignore\033[0m (ignore" << ::std::endl
+       << "                          build flags). The default mode is \033[1massign\033[0m. Note that" << ::std::endl
+       << "                          compiler mode options, if any, are used as" << ::std::endl
+       << "                          configured." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-maint-option\033[0m \033[4mo\033[0m   Alternative options to specify in the" << ::std::endl
+       << "                          \033[1mDEB_BUILD_MAINT_OPTIONS\033[0m variable of the \033[1mrules\033[0m file." << ::std::endl
+       << "                          To specify multiple maintainer options repeat this" << ::std::endl
+       << "                          option and/or specify them as a single value" << ::std::endl
+       << "                          separated with spaces." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-build-option\033[0m \033[4mo\033[0m   Additional option to pass to the \033[1mdpkg-buildpackage\033[0m" << ::std::endl
+       << "                          program. Repeat this option to specify multiple build" << ::std::endl
+       << "                          options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-build-meta\033[0m \033[4mdata\033[0m  Alternative or additional build metadata to include" << ::std::endl
+       << "                          in the binary package version. If the specified value" << ::std::endl
+       << "                          starts/ends with \033[1m+\033[0m then the value (with \033[1m+\033[0m removed) is" << ::std::endl
+       << "                          added after/before the default metadata. Otherwise it" << ::std::endl
+       << "                          is used as is instead of the default metadata. If" << ::std::endl
+       << "                          empty value is specified, then no build metadata is" << ::std::endl
+       << "                          included. By default, the build metadata is the \033[1mID\033[0m" << ::std::endl
+       << "                          and \033[1mVERSION_ID\033[0m components from \033[1mos-release(5)\033[0m, for" << ::std::endl
+       << "                          example, \033[1mdebian10\033[0m in version \033[1m1.2.3-0~debian10\033[0m. See" << ::std::endl
+       << "                          also \033[1m--os-release-*\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-section\033[0m \033[4mv\033[0m        Alternative \033[1mSection\033[0m \033[1mcontrol\033[0m file field value for the" << ::std::endl
+       << "                          main binary package. The default is either \033[1mlibs\033[0m or" << ::std::endl
+       << "                          \033[1mdevel\033[0m, depending on the package type." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-priority\033[0m \033[4mv\033[0m       Alternative \033[1mPriority\033[0m \033[1mcontrol\033[0m file field value. The" << ::std::endl
+       << "                          default is \033[1moptional\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-maintainer\033[0m \033[4mv\033[0m     Alternative \033[1mMaintainer\033[0m \033[1mcontrol\033[0m file field value. The" << ::std::endl
+       << "                          default is the \033[1mpackage-email\033[0m value from package" << ::std::endl
+       << "                          \033[1mmanifest\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-architecture\033[0m \033[4mv\033[0m   Alternative \033[1mArchitecture\033[0m \033[1mcontrol\033[0m file field value for" << ::std::endl
+       << "                          the main binary package, normally \033[1mall\033[0m" << ::std::endl
+       << "                          (architecture-independent). The default is \033[1many\033[0m" << ::std::endl
+       << "                          (architecture-dependent)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-main-langdep\033[0m \033[4mv\033[0m   Override the language runtime dependencies (such as" << ::std::endl
+       << "                          \033[1mlibc6\033[0m, \033[1mlibstdc++6\033[0m, etc) in the \033[1mDepends\033[0m \033[1mcontrol\033[0m file" << ::std::endl
+       << "                          field value of the main binary package." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-dev-langdep\033[0m \033[4mv\033[0m    Override the language runtime dependencies (such as" << ::std::endl
+       << "                          \033[1mlibc-dev\033[0m, \033[1mlibstdc++-dev\033[0m, etc) in the \033[1mDepends\033[0m \033[1mcontrol\033[0m" << ::std::endl
+       << "                          file field value of the development (\033[1m-dev\033[0m) binary" << ::std::endl
+       << "                          package." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-main-extradep\033[0m \033[4mv\033[0m  Extra dependencies to add to the \033[1mDepends\033[0m \033[1mcontrol\033[0m file" << ::std::endl
+       << "                          field value of the main binary package." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--debian-dev-extradep\033[0m \033[4mv\033[0m   Extra dependencies to add to the \033[1mDepends\033[0m \033[1mcontrol\033[0m file" << ::std::endl
+       << "                          field value of the development (\033[1m-dev\033[0m) binary package." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_bindist_debian_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_bindist_debian_options_map;
+
+  static _cli_pkg_bindist_debian_options_map _cli_pkg_bindist_debian_options_map_;
+
+  struct _cli_pkg_bindist_debian_options_map_init
+  {
+    _cli_pkg_bindist_debian_options_map_init ()
+    {
+      _cli_pkg_bindist_debian_options_map_["--debian-prepare-only"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, &pkg_bindist_debian_options::debian_prepare_only_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-buildflags"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_buildflags_,
+        &pkg_bindist_debian_options::debian_buildflags_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-maint-option"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, strings, &pkg_bindist_debian_options::debian_maint_option_,
+        &pkg_bindist_debian_options::debian_maint_option_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-build-option"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, strings, &pkg_bindist_debian_options::debian_build_option_,
+        &pkg_bindist_debian_options::debian_build_option_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-build-meta"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_build_meta_,
+        &pkg_bindist_debian_options::debian_build_meta_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-section"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_section_,
+        &pkg_bindist_debian_options::debian_section_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-priority"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_priority_,
+        &pkg_bindist_debian_options::debian_priority_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-maintainer"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_maintainer_,
+        &pkg_bindist_debian_options::debian_maintainer_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-architecture"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_architecture_,
+        &pkg_bindist_debian_options::debian_architecture_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-main-langdep"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_main_langdep_,
+        &pkg_bindist_debian_options::debian_main_langdep_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-dev-langdep"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_dev_langdep_,
+        &pkg_bindist_debian_options::debian_dev_langdep_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-main-extradep"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_main_extradep_,
+        &pkg_bindist_debian_options::debian_main_extradep_specified_ >;
+      _cli_pkg_bindist_debian_options_map_["--debian-dev-extradep"] =
+      &::bpkg::cli::thunk< pkg_bindist_debian_options, string, &pkg_bindist_debian_options::debian_dev_extradep_,
+        &pkg_bindist_debian_options::debian_dev_extradep_specified_ >;
+    }
+  };
+
+  static _cli_pkg_bindist_debian_options_map_init _cli_pkg_bindist_debian_options_map_init_;
+
+  bool pkg_bindist_debian_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_bindist_debian_options_map::const_iterator i (_cli_pkg_bindist_debian_options_map_.find (o));
+
+    if (i != _cli_pkg_bindist_debian_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool pkg_bindist_debian_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // pkg_bindist_fedora_options
+  //
+
+  pkg_bindist_fedora_options::
+  pkg_bindist_fedora_options ()
+  : fedora_prepare_only_ (),
+    fedora_buildflags_ ("assign"),
+    fedora_buildflags_specified_ (false),
+    fedora_build_option_ (),
+    fedora_build_option_specified_ (false),
+    fedora_query_option_ (),
+    fedora_query_option_specified_ (false),
+    fedora_dist_tag_ (),
+    fedora_dist_tag_specified_ (false),
+    fedora_packager_ (),
+    fedora_packager_specified_ (false),
+    fedora_build_arch_ (),
+    fedora_build_arch_specified_ (false),
+    fedora_main_langreq_ (),
+    fedora_main_langreq_specified_ (false),
+    fedora_devel_langreq_ (),
+    fedora_devel_langreq_specified_ (false),
+    fedora_stat_langreq_ (),
+    fedora_stat_langreq_specified_ (false),
+    fedora_main_extrareq_ (),
+    fedora_main_extrareq_specified_ (false),
+    fedora_devel_extrareq_ (),
+    fedora_devel_extrareq_specified_ (false),
+    fedora_stat_extrareq_ (),
+    fedora_stat_extrareq_specified_ (false)
+  {
+  }
+
+  bool pkg_bindist_fedora_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_fedora_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_fedora_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_fedora_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_fedora_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_bindist_fedora_options::
+  merge (const pkg_bindist_fedora_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    if (a.fedora_prepare_only_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->fedora_prepare_only_, a.fedora_prepare_only_);
+    }
+
+    if (a.fedora_buildflags_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->fedora_buildflags_, a.fedora_buildflags_);
+      this->fedora_buildflags_specified_ = true;
+    }
+
+    if (a.fedora_build_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_build_option_, a.fedora_build_option_);
+      this->fedora_build_option_specified_ = true;
+    }
+
+    if (a.fedora_query_option_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_query_option_, a.fedora_query_option_);
+      this->fedora_query_option_specified_ = true;
+    }
+
+    if (a.fedora_dist_tag_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->fedora_dist_tag_, a.fedora_dist_tag_);
+      this->fedora_dist_tag_specified_ = true;
+    }
+
+    if (a.fedora_packager_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->fedora_packager_, a.fedora_packager_);
+      this->fedora_packager_specified_ = true;
+    }
+
+    if (a.fedora_build_arch_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->fedora_build_arch_, a.fedora_build_arch_);
+      this->fedora_build_arch_specified_ = true;
+    }
+
+    if (a.fedora_main_langreq_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_main_langreq_, a.fedora_main_langreq_);
+      this->fedora_main_langreq_specified_ = true;
+    }
+
+    if (a.fedora_devel_langreq_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_devel_langreq_, a.fedora_devel_langreq_);
+      this->fedora_devel_langreq_specified_ = true;
+    }
+
+    if (a.fedora_stat_langreq_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_stat_langreq_, a.fedora_stat_langreq_);
+      this->fedora_stat_langreq_specified_ = true;
+    }
+
+    if (a.fedora_main_extrareq_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_main_extrareq_, a.fedora_main_extrareq_);
+      this->fedora_main_extrareq_specified_ = true;
+    }
+
+    if (a.fedora_devel_extrareq_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_devel_extrareq_, a.fedora_devel_extrareq_);
+      this->fedora_devel_extrareq_specified_ = true;
+    }
+
+    if (a.fedora_stat_extrareq_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->fedora_stat_extrareq_, a.fedora_stat_extrareq_);
+      this->fedora_stat_extrareq_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_bindist_fedora_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mFEDORA DESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The Fedora binary packages are generated by producing the standard RPM spec" << ::std::endl
+       << "file and then invoking \033[1mrpmbuild(8)\033[0m to build the binary package from that. While" << ::std::endl
+       << "this approach is normally used to build packages from source, this" << ::std::endl
+       << "implementation \"pretends\" that this is what's happening by overriding a number" << ::std::endl
+       << "of RPM spec file sections to invoke the \033[1mbuild2\033[0m build system on the required" << ::std::endl
+       << "packages directly in their \033[1mbpkg\033[0m configuration locations." << ::std::endl
+       << ::std::endl
+       << "The \033[1mrpmdevtools\033[0m Fedora package must be installed before invocation. Typical" << ::std::endl
+       << "invocation:" << ::std::endl
+       << ::std::endl
+       << "bpkg build libhello" << ::std::endl
+       << "bpkg test libhello" << ::std::endl
+       << "bpkg bindist libhello" << ::std::endl
+       << ::std::endl
+       << "The resulting binary packages are placed into the standard \033[1mrpmbuild\033[0m output" << ::std::endl
+       << "directory (normally \033[1m~/rpmbuild/RPMS/\033[0m\033[4march\033[0m\033[1m/\033[0m\033[0m)." << ::std::endl
+       << ::std::endl
+       << "Unless the \033[1m--recursive\033[0m option \033[1mauto\033[0m or \033[1mfull\033[0m modes are specified, dependencies of" << ::std::endl
+       << "the specified package are translated to dependencies in the resulting binary" << ::std::endl
+       << "package using names and versions that refer to packages that would be generated" << ::std::endl
+       << "by the \033[1mpkg-bindist\033[0m command (called \"non-native\" packages). If instead you would" << ::std::endl
+       << "like certain dependencies to refer to binary packages provided by the" << ::std::endl
+       << "distribution (called \"native\" packages), then you need to arrange for them to" << ::std::endl
+       << "be built as system (see \033[1mbpkg-pkg-build(1)\033[0m for details). For example, if our" << ::std::endl
+       << "\033[1mlibhello\033[0m has a dependency on \033[1mlibsqlite3\033[0m and we would like the binary package" << ::std::endl
+       << "for \033[1mlibhello\033[0m to refer to \033[1msqlite-libs\033[0m from Fedora (or alike), then the" << ::std::endl
+       << "\033[1mpkg-build\033[0m command would need to be (\033[1m--sys-install\033[0m is optional):" << ::std::endl
+       << ::std::endl
+       << "bpkg build --sys-install libhello ?sys:libsqlite3" << ::std::endl
+       << ::std::endl
+       << "Such a package with native dependencies can then be installed (including any" << ::std::endl
+       << "missing native dependencies) using the \033[1mdnf install\033[0m command. For example:" << ::std::endl
+       << ::std::endl
+       << "sudo dnf install libhello-1.2.3-1.fc35.x86_64.rpm \\" << ::std::endl
+       << "                 libhello-devel-1.2.3-1.fc35.x86_64.rpm" << ::std::endl
+       << ::std::endl
+       << "See Fedora Package Mapping for Production (bpkg#bindist-mapping-fedora-produce)" << ::std::endl
+       << "for details on \033[1mbpkg\033[0m to Fedora package name and version mapping." << ::std::endl;
+
+    os << std::endl
+       << "\033[1mPKG-BINDIST FEDORA OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-prepare-only\033[0m     Prepare the RPM spec file but do not invoke \033[1mrpmbuild\033[0m" << ::std::endl
+       << "                          to generate the binary package, printing its command" << ::std::endl
+       << "                          line instead unless requested to be quiet." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-buildflags\033[0m \033[4mmode\033[0m  Package build flags (\033[1m%{build_*flags}\033[0m macros) usage" << ::std::endl
+       << "                          mode. Valid \033[4mmode\033[0m values are \033[1massign\033[0m (use the build" << ::std::endl
+       << "                          flags instead of configured), \033[1mappend\033[0m (use the build" << ::std::endl
+       << "                          flags in addition to configured, putting them last)," << ::std::endl
+       << "                          \033[1mprepend\033[0m (use the build flags in addition to" << ::std::endl
+       << "                          configured, putting them first), and \033[1mignore\033[0m (ignore" << ::std::endl
+       << "                          build flags). The default mode is \033[1massign\033[0m. Note that" << ::std::endl
+       << "                          compiler mode options, if any, are used as" << ::std::endl
+       << "                          configured." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-build-option\033[0m \033[4mo\033[0m   Additional option to pass to the \033[1mrpmbuild\033[0m program. If" << ::std::endl
+       << "                          specified, these options must be consistent with the" << ::std::endl
+       << "                          query options (\033[1m--fedora-query-option\033[0m) to result in" << ::std::endl
+       << "                          identical macro expansions. Repeat this option to" << ::std::endl
+       << "                          specify multiple build options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-query-option\033[0m \033[4mo\033[0m   Additional option to pass to the \033[1mrpm\033[0m program. This" << ::std::endl
+       << "                          program is used to query RPM macro values which" << ::std::endl
+       << "                          affect the binary package. If specified, these" << ::std::endl
+       << "                          options must be consistent with the build options" << ::std::endl
+       << "                          (\033[1m--fedora-build-option\033[0m) to result in identical macro" << ::std::endl
+       << "                          expansions. Repeat this option to specify multiple" << ::std::endl
+       << "                          query options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-dist-tag\033[0m \033[4mtag\033[0m     Alternative or additional distribution tag to use in" << ::std::endl
+       << "                          the binary package release. If the specified value" << ::std::endl
+       << "                          starts/ends with \033[1m+\033[0m then the value (with \033[1m+\033[0m removed) is" << ::std::endl
+       << "                          added after/before the default distribution tag." << ::std::endl
+       << "                          Otherwise it is used as is instead of the default" << ::std::endl
+       << "                          tag. If empty value is specified, then no" << ::std::endl
+       << "                          distribution tag is included. The default is a value" << ::std::endl
+       << "                          that identifies the distribution being used to build" << ::std::endl
+       << "                          the package, for example, \033[1mfc35\033[0m for Fedora 35 or \033[1mel8\033[0m" << ::std::endl
+       << "                          for RHEL 8." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-packager\033[0m \033[4mv\033[0m       Alternative \033[1mPackager\033[0m RPM spec file directive value." << ::std::endl
+       << "                          The default is the \033[1mpackage-email\033[0m value from package" << ::std::endl
+       << "                          \033[1mmanifest\033[0m. If empty value is specified, then the" << ::std::endl
+       << "                          \033[1mPackager\033[0m directive is omitted from the spec file." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-build-arch\033[0m \033[4mv\033[0m     \033[1mBuildArch\033[0m RPM spec file directive value for the main" << ::std::endl
+       << "                          binary package, normally \033[1mnoarch\033[0m" << ::std::endl
+       << "                          (architecture-independent). By default the directive" << ::std::endl
+       << "                          is omitted, assuming that the package is" << ::std::endl
+       << "                          architecture-dependent." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-main-langreq\033[0m \033[4mv\033[0m   Override the language runtime dependencies (such as" << ::std::endl
+       << "                          \033[1mglibc\033[0m, \033[1mlibstdc++\033[0m, etc) of the main binary package by" << ::std::endl
+       << "                          replacing the corresponding \033[1mRequires\033[0m RPM spec file" << ::std::endl
+       << "                          directives. If empty value is specified then no" << ::std::endl
+       << "                          language runtime dependencies are specified. Repeat" << ::std::endl
+       << "                          this option to specify multiple language runtime" << ::std::endl
+       << "                          dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-devel-langreq\033[0m \033[4mv\033[0m  Override the language runtime dependencies (such as" << ::std::endl
+       << "                          \033[1mglibc-devel\033[0m, \033[1mlibstdc++-devel\033[0m, etc) of the development" << ::std::endl
+       << "                          (\033[1m-devel\033[0m) binary package by replacing the" << ::std::endl
+       << "                          corresponding \033[1mRequires\033[0m RPM spec file directives. If" << ::std::endl
+       << "                          empty value is specified then no language runtime" << ::std::endl
+       << "                          dependencies are specified. Repeat this option to" << ::std::endl
+       << "                          specify multiple language runtime dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-stat-langreq\033[0m \033[4mv\033[0m   Override the language runtime dependencies (such as" << ::std::endl
+       << "                          \033[1mglibc-static\033[0m, \033[1mlibstdc++-static\033[0m, etc) of the static" << ::std::endl
+       << "                          libraries (\033[1m-static\033[0m) binary package by replacing the" << ::std::endl
+       << "                          corresponding \033[1mRequires\033[0m RPM spec file directives. If" << ::std::endl
+       << "                          empty value is specified then no language runtime" << ::std::endl
+       << "                          dependencies are specified. Repeat this option to" << ::std::endl
+       << "                          specify multiple language runtime dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-main-extrareq\033[0m \033[4mv\033[0m  Extra dependency to add to the main binary package as" << ::std::endl
+       << "                          an additional \033[1mRequires\033[0m RPM spec file directive." << ::std::endl
+       << "                          Repeat this option to specify multiple extra" << ::std::endl
+       << "                          dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-devel-extrareq\033[0m \033[4mv\033[0m Extra dependency to add to the development (\033[1m-devel\033[0m)" << ::std::endl
+       << "                          binary package as an additional \033[1mRequires\033[0m RPM spec" << ::std::endl
+       << "                          file directive. Repeat this option to specify" << ::std::endl
+       << "                          multiple extra dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fedora-stat-extrareq\033[0m \033[4mv\033[0m  Extra dependency to add to the static libraries" << ::std::endl
+       << "                          (\033[1m-static\033[0m) binary package as an additional \033[1mRequires\033[0m" << ::std::endl
+       << "                          RPM spec file directive. Repeat this option to" << ::std::endl
+       << "                          specify multiple extra dependencies." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_bindist_fedora_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_bindist_fedora_options_map;
+
+  static _cli_pkg_bindist_fedora_options_map _cli_pkg_bindist_fedora_options_map_;
+
+  struct _cli_pkg_bindist_fedora_options_map_init
+  {
+    _cli_pkg_bindist_fedora_options_map_init ()
+    {
+      _cli_pkg_bindist_fedora_options_map_["--fedora-prepare-only"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, &pkg_bindist_fedora_options::fedora_prepare_only_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-buildflags"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, string, &pkg_bindist_fedora_options::fedora_buildflags_,
+        &pkg_bindist_fedora_options::fedora_buildflags_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-build-option"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_build_option_,
+        &pkg_bindist_fedora_options::fedora_build_option_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-query-option"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_query_option_,
+        &pkg_bindist_fedora_options::fedora_query_option_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-dist-tag"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, string, &pkg_bindist_fedora_options::fedora_dist_tag_,
+        &pkg_bindist_fedora_options::fedora_dist_tag_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-packager"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, string, &pkg_bindist_fedora_options::fedora_packager_,
+        &pkg_bindist_fedora_options::fedora_packager_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-build-arch"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, string, &pkg_bindist_fedora_options::fedora_build_arch_,
+        &pkg_bindist_fedora_options::fedora_build_arch_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-main-langreq"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_main_langreq_,
+        &pkg_bindist_fedora_options::fedora_main_langreq_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-devel-langreq"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_devel_langreq_,
+        &pkg_bindist_fedora_options::fedora_devel_langreq_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-stat-langreq"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_stat_langreq_,
+        &pkg_bindist_fedora_options::fedora_stat_langreq_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-main-extrareq"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_main_extrareq_,
+        &pkg_bindist_fedora_options::fedora_main_extrareq_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-devel-extrareq"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_devel_extrareq_,
+        &pkg_bindist_fedora_options::fedora_devel_extrareq_specified_ >;
+      _cli_pkg_bindist_fedora_options_map_["--fedora-stat-extrareq"] =
+      &::bpkg::cli::thunk< pkg_bindist_fedora_options, strings, &pkg_bindist_fedora_options::fedora_stat_extrareq_,
+        &pkg_bindist_fedora_options::fedora_stat_extrareq_specified_ >;
+    }
+  };
+
+  static _cli_pkg_bindist_fedora_options_map_init _cli_pkg_bindist_fedora_options_map_init_;
+
+  bool pkg_bindist_fedora_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_bindist_fedora_options_map::const_iterator i (_cli_pkg_bindist_fedora_options_map_.find (o));
+
+    if (i != _cli_pkg_bindist_fedora_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool pkg_bindist_fedora_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // pkg_bindist_archive_options
+  //
+
+  pkg_bindist_archive_options::
+  pkg_bindist_archive_options ()
+  : archive_prepare_only_ (),
+    archive_type_ (),
+    archive_type_specified_ (false),
+    archive_lang_ (),
+    archive_lang_specified_ (false),
+    archive_lang_impl_ (),
+    archive_lang_impl_specified_ (false),
+    archive_no_cpu_ (),
+    archive_no_os_ (),
+    archive_build_meta_ (),
+    archive_build_meta_specified_ (false),
+    archive_install_root_ (),
+    archive_install_root_specified_ (false),
+    archive_install_config_ (),
+    archive_split_ (),
+    archive_split_specified_ (false)
+  {
+  }
+
+  bool pkg_bindist_archive_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_archive_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_archive_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_archive_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_archive_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_bindist_archive_options::
+  merge (const pkg_bindist_archive_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    if (a.archive_prepare_only_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->archive_prepare_only_, a.archive_prepare_only_);
+    }
+
+    if (a.archive_type_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->archive_type_, a.archive_type_);
+      this->archive_type_specified_ = true;
+    }
+
+    if (a.archive_lang_specified_)
+    {
+      ::bpkg::cli::parser< std::multimap<string, string>>::merge (
+        this->archive_lang_, a.archive_lang_);
+      this->archive_lang_specified_ = true;
+    }
+
+    if (a.archive_lang_impl_specified_)
+    {
+      ::bpkg::cli::parser< std::multimap<string, string>>::merge (
+        this->archive_lang_impl_, a.archive_lang_impl_);
+      this->archive_lang_impl_specified_ = true;
+    }
+
+    if (a.archive_no_cpu_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->archive_no_cpu_, a.archive_no_cpu_);
+    }
+
+    if (a.archive_no_os_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->archive_no_os_, a.archive_no_os_);
+    }
+
+    if (a.archive_build_meta_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->archive_build_meta_, a.archive_build_meta_);
+      this->archive_build_meta_specified_ = true;
+    }
+
+    if (a.archive_install_root_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->archive_install_root_, a.archive_install_root_);
+      this->archive_install_root_specified_ = true;
+    }
+
+    if (a.archive_install_config_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->archive_install_config_, a.archive_install_config_);
+    }
+
+    if (a.archive_split_specified_)
+    {
+      ::bpkg::cli::parser< std::map<string, string>>::merge (
+        this->archive_split_, a.archive_split_);
+      this->archive_split_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_bindist_archive_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mARCHIVE DESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The installation archive binary packages are generated by invoking the \033[1mbuild2\033[0m" << ::std::endl
+       << "build system on the required packages directly in their \033[1mbpkg\033[0m configuration" << ::std::endl
+       << "locations and installing them into the binary package directory using the" << ::std::endl
+       << "\033[1mconfig.install.chroot\033[0m mechanism. Then this directory is packaged with \033[1mtar\033[0m or" << ::std::endl
+       << "\033[1mzip\033[0m to produce one or more binary package archives." << ::std::endl
+       << ::std::endl
+       << "The generation of installation archive packages is never the default and should" << ::std::endl
+       << "be requested explicitly with the \033[1m--distribution=archive\033[0m option. The" << ::std::endl
+       << "installation directory layout and the package archives to generate can be" << ::std::endl
+       << "specified with the \033[1m--archive-install-*\033[0m and \033[1m--archive-type\033[0m options (refer to" << ::std::endl
+       << "their documentation for defaults)." << ::std::endl
+       << ::std::endl
+       << "The binary package directory (the top-level directory inside the archive) as" << ::std::endl
+       << "well as the archive file base (the file name without the extension) are the" << ::std::endl
+       << "same and have the following form:" << ::std::endl
+       << ::std::endl
+       << "\033[4mpackage\033[0m-\033[4mversion\033[0m-\033[4mbuild_metadata\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "Where \033[4mpackage\033[0m is the package name and \033[4mversion\033[0m is the \033[1mbpkg\033[0m package version." << ::std::endl
+       << "Unless overridden with the \033[1m--archive-build-meta\033[0m option, \033[4mbuild_metadata\033[0m has the" << ::std::endl
+       << "following form:" << ::std::endl
+       << ::std::endl
+       << "\033[4mcpu\033[0m-\033[4mos\033[0m[-\033[4mlangrt\033[0m...]\033[0m" << ::std::endl
+       << ::std::endl
+       << "Where \033[4mcpu\033[0m is the target CPU (for example, \033[1mx86_64\033[0m or \033[1maarch64\033[0m; omitted if" << ::std::endl
+       << "\033[1m--archive-no-cpu\033[0m is specified), \033[4mos\033[0m is the \033[1mID\033[0m and \033[1mVERSION_ID\033[0m components from" << ::std::endl
+       << "\033[1mos-release(5)\033[0m (or equivalent, for example, \033[1mdebian11\033[0m or \033[1mwindows10\033[0m; omitted if" << ::std::endl
+       << "\033[1m--archive-no-os\033[0m is specified), and \033[4mlangrt\033[0m are the language runtimes as mapped" << ::std::endl
+       << "by the \033[1m--archive-lang*\033[0m options (for example, \033[1mgcc12\033[0m or \033[1mmsvc17.4\033[0m)." << ::std::endl
+       << ::std::endl
+       << "For example, given the following invocation on Debian 11 running on \033[1mx86_64\033[0m:" << ::std::endl
+       << ::std::endl
+       << "bpkg build libhello" << ::std::endl
+       << "bpkg test libhello" << ::std::endl
+       << "bpkg bindist              \\" << ::std::endl
+       << "  -o /tmp/output/         \\" << ::std::endl
+       << "  --distribution=archive  \\" << ::std::endl
+       << "  --archive-lang cc=gcc12 \\" << ::std::endl
+       << "  libhello" << ::std::endl
+       << ::std::endl
+       << "We will end up with the package archive in the following form:" << ::std::endl
+       << ::std::endl
+       << "libhello-1.2.3-x86_64-debian11-gcc12.tar.xz" << ::std::endl
+       << ::std::endl
+       << "The recommended language runtime id format is the runtime name followed by the" << ::std::endl
+       << "version, for example, \033[1mgcc12\033[0m or \033[1mmsvc17.4\033[0m. Note that its purpose is not to" << ::std::endl
+       << "provide a precise specification of requirements but rather to help the user of" << ::std::endl
+       << "a binary package to pick the appropriate variant. Refer to the \033[1m--archive-lang*\033[0m" << ::std::endl
+       << "options documentation for details on the mapping semantics." << ::std::endl
+       << ::std::endl
+       << "Instead of mapping languages individually you can specify entire build metadata" << ::std::endl
+       << "as a single value with the \033[1m--archive-build-meta\033[0m (it is also possible to add" << ::std::endl
+       << "additional metadata; see the option documentation for details). For example:" << ::std::endl
+       << ::std::endl
+       << "bpkg bindist                              \\" << ::std::endl
+       << "  -o /tmp/output/                         \\" << ::std::endl
+       << "  --distribution=archive                  \\" << ::std::endl
+       << "  --archive-build-meta=x86_64-linux-glibc" << ::std::endl
+       << "  libhello" << ::std::endl
+       << ::std::endl
+       << "This will produce the package archive in the following form:" << ::std::endl
+       << ::std::endl
+       << "libhello-1.2.3-x86_64-linux-glibc.tar.xz" << ::std::endl
+       << ::std::endl
+       << "To install the binary package from archive simply unpack it using \033[1mtar\033[0m or \033[1mzip\033[0m." << ::std::endl
+       << "You can use the \033[1m--strip-components\033[0m \033[1mtar\033[0m option to remove the top-level package" << ::std::endl
+       << "directory (the same can be achieved for \033[1mzip\033[0m archives by using \033[1mbsdtar\033[0m on" << ::std::endl
+       << "Windows). For example, to unpack the package contents so that they end up in" << ::std::endl
+       << "\033[1m/usr/local/\033[0m:" << ::std::endl
+       << ::std::endl
+       << "sudo tar -xf libhello-1.2.3-x86_64-debian11-gcc12.tar.xz \\" << ::std::endl
+       << "  -C / --strip-components=1" << ::std::endl
+       << ::std::endl
+       << "If you expect the binary package to be unpacked into a directory other than its" << ::std::endl
+       << "original installation directory (\033[1m--archive-install-root\033[0m), then it's recommended" << ::std::endl
+       << "to make it relocatable by specifying the \033[1mconfig.install.relocatable=true\033[0m" << ::std::endl
+       << "configuration variable. For example:" << ::std::endl
+       << ::std::endl
+       << "bpkg bindist                      \\" << ::std::endl
+       << "  ...                             \\" << ::std::endl
+       << "  config.install.relocatable=true \\" << ::std::endl
+       << "  libhello" << ::std::endl
+       << ::std::endl
+       << "Note that not all source packages support relocatable installation (see" << ::std::endl
+       << "Rolocatable Installation (b#install-reloc) for details)." << ::std::endl
+       << ::std::endl
+       << "Another mechanism that can useful when generating archive packages is the" << ::std::endl
+       << "ability to filter the files being installed. This, for example, can be used to" << ::std::endl
+       << "create binary packages that don't contain any development-related files. See" << ::std::endl
+       << "Installation Filtering (b#install-filter) for details. See also the" << ::std::endl
+       << "\033[1m--archive-split\033[0m option." << ::std::endl
+       << ::std::endl
+       << "The installation archive package can be generated for a target other than the" << ::std::endl
+       << "host by specifying the target triplet with the \033[1m--architecture\033[0m option. In this" << ::std::endl
+       << "case the \033[1mbpkg\033[0m configuration is assumed to be appropriately configured for" << ::std::endl
+       << "cross-compiling to the specified target. You will also need to explicitly" << ::std::endl
+       << "specify the \033[1m--archive-install-root\033[0m option (or \033[1m--archive-install-config\033[0m) as well" << ::std::endl
+       << "as the \033[1m--os-release-id\033[0m option (and likely want to specify other \033[1m--os-release-*\033[0m" << ::std::endl
+       << "options). For example, for cross-compiling from Linux to Windows using the" << ::std::endl
+       << "MinGW GCC toolchain:" << ::std::endl
+       << ::std::endl
+       << "bpkg bindist                        \\" << ::std::endl
+       << "  --distribution=archive            \\" << ::std::endl
+       << "  --architecture=x86_64-w64-mingw32 \\" << ::std::endl
+       << "  --os-release-id=windows           \\" << ::std::endl
+       << "  --os-release-name=Windows         \\" << ::std::endl
+       << "  --os-release-version-id=10        \\" << ::std::endl
+       << "  --archive-install-root /          \\" << ::std::endl
+       << "  --archive-lang cc=mingw_w64_gcc12 \\" << ::std::endl
+       << "  ..." << ::std::endl;
+
+    os << std::endl
+       << "\033[1mPKG-BINDIST ARCHIVE OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-prepare-only\033[0m    Prepare all the package contents but do not create" << ::std::endl
+       << "                          the binary package archive, printing its directory" << ::std::endl
+       << "                          instead unless requested to be quiet. Implies" << ::std::endl
+       << "                          \033[1m--keep-output\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-type\033[0m \033[4mext\033[0m        Archive type to create specified as a file extension," << ::std::endl
+       << "                          for example, \033[1mtar.xz\033[0m, \033[1mtar.gz\033[0m, \033[1mtar\033[0m, \033[1mzip\033[0m. Repeat this" << ::std::endl
+       << "                          option to generate multiple archive types. If" << ::std::endl
+       << "                          unspecified, then a default type appropriate for the" << ::std::endl
+       << "                          target operating system is used, currently \033[1mzip\033[0m for" << ::std::endl
+       << "                          Windows and \033[1mtar.xz\033[0m for POSIX. Note, however, that" << ::std::endl
+       << "                          these defaults may change in the future." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-lang\033[0m \033[4mln\033[0m=\033[4mrt\033[0m      Map interface language name \033[4mln\033[0m to runtime id \033[4mrt\033[0m. If" << ::std::endl
+       << "                          no mapping is found for an interface language in this" << ::std::endl
+       << "                          map, then fallback to the \033[1m--archive-lang-impl\033[0m map. If" << ::std::endl
+       << "                          still no mapping is found, then fail. If the" << ::std::endl
+       << "                          information about an interface language is" << ::std::endl
+       << "                          unimportant and should be ignored, then empty runtime" << ::std::endl
+       << "                          id can be specified. Note that the mapping specified" << ::std::endl
+       << "                          with this option is only considered if the package" << ::std::endl
+       << "                          type is a library (for other package types all" << ::std::endl
+       << "                          languages used are implementation). Note also that" << ::std::endl
+       << "                          multiple runtime ids specified for the same language" << ::std::endl
+       << "                          are combined except for an empty id, which is treated" << ::std::endl
+       << "                          as a request to clear previous entries." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-lang-impl\033[0m \033[4mln\033[0m=\033[4mrt\033[0m Map implementation language name \033[4mln\033[0m to runtime id \033[4mrt\033[0m." << ::std::endl
+       << "                          If no mapping is found for an implementation language" << ::std::endl
+       << "                          in this map, then assume the information about this" << ::std::endl
+       << "                          implementation language is unimportant and ignore it" << ::std::endl
+       << "                          (examples of such cases include static linking as" << ::std::endl
+       << "                          well as a language runtime that is always present)." << ::std::endl
+       << "                          See \033[1m--archive-lang\033[0m for background." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-no-cpu\033[0m          Assume the package is CPU architecture-independent" << ::std::endl
+       << "                          and omit it from the binary package directory name" << ::std::endl
+       << "                          and archive file base." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-no-os\033[0m           Assume the package is operating system-independent" << ::std::endl
+       << "                          and omit it from the binary package directory name" << ::std::endl
+       << "                          and archive file base." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-build-meta\033[0m \033[4mdata\033[0m Alternative or additional build metadata to include" << ::std::endl
+       << "                          after the version in the binary package directory and" << ::std::endl
+       << "                          file names. If the specified value starts/ends with" << ::std::endl
+       << "                          \033[1m+\033[0m then the value (with \033[1m+\033[0m removed) is added" << ::std::endl
+       << "                          after/before the default metadata. Otherwise it is" << ::std::endl
+       << "                          used as is instead of the default metadata. If empty" << ::std::endl
+       << "                          value is specified, then no build metadata is" << ::std::endl
+       << "                          included." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-install-root\033[0m \033[4md\033[0m  Alternative installation root directory. The default" << ::std::endl
+       << "                          is \033[1m/usr/local/\033[0m on POSIX and \033[1mC:\\\033[0m\033[4mproject\033[0m\033[1m\\\033[0m\033[0m on Windows," << ::std::endl
+       << "                          where \033[4mproject\033[0m is the \033[1mproject\033[0m" << ::std::endl
+       << "                          (bpkg#manifest-package-project) package manifest" << ::std::endl
+       << "                          value." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-install-config\033[0m  Use the installation directory layout" << ::std::endl
+       << "                          (\033[1mconfig.install.*\033[0m variables) as configured instead of" << ::std::endl
+       << "                          overriding them with defaults appropriate for the" << ::std::endl
+       << "                          target operating system. Note that this includes" << ::std::endl
+       << "                          \033[1mconfig.install.private\033[0m and \033[1mconfig.bin.rpath\033[0m if needed" << ::std::endl
+       << "                          for a private installation. Note also that the" << ::std::endl
+       << "                          \033[1mconfig.install.root\033[0m value is still overridden with" << ::std::endl
+       << "                          the \033[1m--archive-install-root\033[0m option value if specified." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--archive-split\033[0m \033[4mkey\033[0m=\033[4mfilt\033[0m  Split the installation into multiple binary packages." << ::std::endl
+       << "                          Specifically, for each \033[4mkey\033[0m=\033[4mfilt\033[0m pair, perform the" << ::std::endl
+       << "                          \033[1minstall\033[0m operation with \033[1mconfig.install.filter=\033[0m\033[4mfilt\033[0m\033[0m and" << ::std::endl
+       << "                          package the resulting files as" << ::std::endl
+       << "                          \033[4mpackage-key-version-build_metadata\033[0m omitting the \033[4m-key\033[0m" << ::std::endl
+       << "                          part if \033[4mkey\033[0m is empty. Note that wildcard patterns in" << ::std::endl
+       << "                          \033[4mfilt\033[0m must be quoted. See Installation Filtering" << ::std::endl
+       << "                          (b#install-filter) for background." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_bindist_archive_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_bindist_archive_options_map;
+
+  static _cli_pkg_bindist_archive_options_map _cli_pkg_bindist_archive_options_map_;
+
+  struct _cli_pkg_bindist_archive_options_map_init
+  {
+    _cli_pkg_bindist_archive_options_map_init ()
+    {
+      _cli_pkg_bindist_archive_options_map_["--archive-prepare-only"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, &pkg_bindist_archive_options::archive_prepare_only_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-type"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, strings, &pkg_bindist_archive_options::archive_type_,
+        &pkg_bindist_archive_options::archive_type_specified_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-lang"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, std::multimap<string, string>, &pkg_bindist_archive_options::archive_lang_,
+        &pkg_bindist_archive_options::archive_lang_specified_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-lang-impl"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, std::multimap<string, string>, &pkg_bindist_archive_options::archive_lang_impl_,
+        &pkg_bindist_archive_options::archive_lang_impl_specified_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-no-cpu"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, &pkg_bindist_archive_options::archive_no_cpu_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-no-os"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, &pkg_bindist_archive_options::archive_no_os_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-build-meta"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, string, &pkg_bindist_archive_options::archive_build_meta_,
+        &pkg_bindist_archive_options::archive_build_meta_specified_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-install-root"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, dir_path, &pkg_bindist_archive_options::archive_install_root_,
+        &pkg_bindist_archive_options::archive_install_root_specified_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-install-config"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, &pkg_bindist_archive_options::archive_install_config_ >;
+      _cli_pkg_bindist_archive_options_map_["--archive-split"] =
+      &::bpkg::cli::thunk< pkg_bindist_archive_options, std::map<string, string>, &pkg_bindist_archive_options::archive_split_,
+        &pkg_bindist_archive_options::archive_split_specified_ >;
+    }
+  };
+
+  static _cli_pkg_bindist_archive_options_map_init _cli_pkg_bindist_archive_options_map_init_;
+
+  bool pkg_bindist_archive_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_bindist_archive_options_map::const_iterator i (_cli_pkg_bindist_archive_options_map_.find (o));
+
+    if (i != _cli_pkg_bindist_archive_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool pkg_bindist_archive_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // pkg_bindist_options
+  //
+
+  pkg_bindist_options::
+  pkg_bindist_options ()
+  {
+  }
+
+  bool pkg_bindist_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_bindist_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_bindist_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_bindist_options::
+  merge (const pkg_bindist_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // pkg_bindist_common_options base
+    //
+    ::bpkg::pkg_bindist_common_options::merge (a);
+
+    // pkg_bindist_debian_options base
+    //
+    ::bpkg::pkg_bindist_debian_options::merge (a);
+
+    // pkg_bindist_fedora_options base
+    //
+    ::bpkg::pkg_bindist_fedora_options::merge (a);
+
+    // pkg_bindist_archive_options base
+    //
+    ::bpkg::pkg_bindist_archive_options::merge (a);
+  }
+
+  ::bpkg::cli::usage_para pkg_bindist_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_bindist_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_bindist_options_map;
+
+  static _cli_pkg_bindist_options_map _cli_pkg_bindist_options_map_;
+
+  struct _cli_pkg_bindist_options_map_init
+  {
+    _cli_pkg_bindist_options_map_init ()
+    {
+    }
+  };
+
+  static _cli_pkg_bindist_options_map_init _cli_pkg_bindist_options_map_init_;
+
+  bool pkg_bindist_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_bindist_options_map::const_iterator i (_cli_pkg_bindist_options_map_.find (o));
+
+    if (i != _cli_pkg_bindist_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // pkg_bindist_common_options base
+    //
+    if (::bpkg::pkg_bindist_common_options::_parse (o, s))
+      return true;
+
+    // pkg_bindist_debian_options base
+    //
+    if (::bpkg::pkg_bindist_debian_options::_parse (o, s))
+      return true;
+
+    // pkg_bindist_fedora_options base
+    //
+    if (::bpkg::pkg_bindist_fedora_options::_parse (o, s))
+      return true;
+
+    // pkg_bindist_archive_options base
+    //
+    if (::bpkg::pkg_bindist_archive_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_bindist_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_bindist_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-bindist\033[0m|\033[1mbindist\033[0m [\033[1m--output-root\033[0m|\033[1m-o\033[0m \033[4mdir\033[0m] [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[4mpkg\033[0m...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-bindist\033[0m command generates a binary distribution package for the" << ::std::endl
+       << "specified package. If additional packages are specified, then they are bundled" << ::std::endl
+       << "in the same distribution package. All the specified packages must have been" << ::std::endl
+       << "previously configured with \033[1mbpkg-pkg-build(1)\033[0m or \033[1mbpkg-pkg-configure(1)\033[0m. For some" << ::std::endl
+       << "system package managers a directory for intermediate files and subdirectories" << ::std::endl
+       << "as well as the resulting binary package may have to be specified explicitly" << ::std::endl
+       << "with the \033[1m--output-root\033[0m|\033[1m-o\033[0m\033[0m option." << ::std::endl
+       << ::std::endl
+       << "Underneath, this command roughly performs the following steps: First it" << ::std::endl
+       << "installs the specified packages similar to the \033[1mbpkg-pkg-install(1)\033[0m command" << ::std::endl
+       << "except that it may override the installation locations (via the" << ::std::endl
+       << "\033[1mconfig.install.*\033[0m variables) to match the distribution's layout. Then it" << ::std::endl
+       << "generates any necessary distribution package metadata files based on the" << ::std::endl
+       << "information from the package \033[1mmanifest\033[0m files. Finally, it invokes the" << ::std::endl
+       << "distribution-specific command to produce the binary package. Unless overridden" << ::std::endl
+       << "with the \033[1m--architecture\033[0m and \033[1m--distribution\033[0m options, the binary package is" << ::std::endl
+       << "generated for the host architecture using the host's standard system package" << ::std::endl
+       << "manager. Additional command line variables (\033[4mvars\033[0m, normally \033[1mconfig.*\033[0m) can be" << ::std::endl
+       << "passed to the build system during the installation step. See the following" << ::std::endl
+       << "distribution-specific description sections below for details and invocation" << ::std::endl
+       << "examples:" << ::std::endl
+       << ::std::endl
+       << "DEBIAN DESCRIPTION" << ::std::endl
+       << ::std::endl
+       << "FEDORA DESCRIPTION" << ::std::endl
+       << ::std::endl
+       << "ARCHIVE DESCRIPTION" << ::std::endl
+       << ::std::endl
+       << "The specified packages may have dependencies and the default behavior is to not" << ::std::endl
+       << "bundle them but rather to specify them as dependencies in the corresponding" << ::std::endl
+       << "distribution package metadata, if applicable. This default behavior can be" << ::std::endl
+       << "overridden with the \033[1m--recursive\033[0m option (see the option description for the" << ::std::endl
+       << "available modes). Note, however, that dependencies that are satisfied by system" << ::std::endl
+       << "packages are always specified as dependencies in the distribution package" << ::std::endl
+       << "metadata (if applicable)." << ::std::endl;
+
+    p = ::bpkg::pkg_bindist_common_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    p = ::bpkg::pkg_bindist_debian_options::print_usage (os, p);
+
+    p = ::bpkg::pkg_bindist_fedora_options::print_usage (os, p);
+
+    p = ::bpkg::pkg_bindist_archive_options::print_usage (os, p);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSTRUCTURED RESULT\033[0m" << ::std::endl
+       << ::std::endl
+       << "Instead of printing to \033[1mstderr\033[0m the list of generated binary packages in a format" << ::std::endl
+       << "more suitable for human consumption, the \033[1mpkg-bindist\033[0m command can be instructed" << ::std::endl
+       << "to write it to \033[1mstdout\033[0m in a machine-readable form by specifying the" << ::std::endl
+       << "\033[1m--structured-result\033[0m option. Currently, the only recognized format value for" << ::std::endl
+       << "this option is \033[1mjson\033[0m with the output being a JSON object that is a serialized" << ::std::endl
+       << "representation of the following C++ struct \033[1mbindist_result\033[0m:" << ::std::endl
+       << ::std::endl
+       << "struct os_release" << ::std::endl
+       << "{" << ::std::endl
+       << "  string           name_id;     // ID" << ::std::endl
+       << "  vector<string>   like_ids;    // ID_LIKE" << ::std::endl
+       << "  optional<string> version_id;  // VERSION_ID" << ::std::endl
+       << "  optional<string> variant_id;  // VARIANT_ID" << ::std::endl
+       << ::std::endl
+       << "  optional<string> name;              // NAME" << ::std::endl
+       << "  optional<string> version_codename;  // VERSION_CODENAME" << ::std::endl
+       << "  optional<string> variant;           // VARIANT" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "struct file" << ::std::endl
+       << "{" << ::std::endl
+       << "  string type;" << ::std::endl
+       << "  string path;" << ::std::endl
+       << "  optional<string> system_name;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "struct package" << ::std::endl
+       << "{" << ::std::endl
+       << "  string           name;" << ::std::endl
+       << "  string           version;" << ::std::endl
+       << "  optional<string> system_version;" << ::std::endl
+       << "  vector<file>     files;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "struct bindist_result" << ::std::endl
+       << "{" << ::std::endl
+       << "  string           distribution;     // --distribution or auto-detected" << ::std::endl
+       << "  string           architecture;     // --architecture or auto-detected" << ::std::endl
+       << "  os_release       os_release;       // --os-release-* or auto-detected" << ::std::endl
+       << "  optional<string> recursive;        // --recursive" << ::std::endl
+       << "  bool             private;          // --private" << ::std::endl
+       << "  bool             dependent_config; // See --allow-dependent-config" << ::std::endl
+       << ::std::endl
+       << "  package          package;" << ::std::endl
+       << "  vector<package>  dependencies;     // Only in --recursive=separate" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "For example:" << ::std::endl
+       << ::std::endl
+       << "{" << ::std::endl
+       << "  \"distribution\": \"debian\"," << ::std::endl
+       << "  \"architecture\": \"amd64\"," << ::std::endl
+       << "  \"os_release\": {" << ::std::endl
+       << "    \"name_id\": \"debian\"," << ::std::endl
+       << "    \"version_id\": \"11\"," << ::std::endl
+       << "    \"name\": \"Debian GNU/Linux\"" << ::std::endl
+       << "  }," << ::std::endl
+       << "  \"package\": {" << ::std::endl
+       << "    \"name\": \"libfoo\"," << ::std::endl
+       << "    \"version\": \"2.5.0-b.23\"," << ::std::endl
+       << "    \"system_version\": \"2.5.0~b.23-0~debian11\"," << ::std::endl
+       << "    \"files\": [" << ::std::endl
+       << "      {" << ::std::endl
+       << "        \"type\": \"main.deb\"," << ::std::endl
+       << "        \"path\": \"/tmp/libfoo_2.5.0~b.23-0~debian11_amd64.deb\"," << ::std::endl
+       << "        \"system_name\": \"libfoo\"" << ::std::endl
+       << "      }," << ::std::endl
+       << "      {" << ::std::endl
+       << "        \"type\": \"dev.deb\"," << ::std::endl
+       << "        \"path\": \"/tmp/libfoo-dev_2.5.0~b.23-0~debian11_amd64.deb\"," << ::std::endl
+       << "        \"system_name\": \"libfoo-dev\"" << ::std::endl
+       << "      }," << ::std::endl
+       << "      ..." << ::std::endl
+       << "    ]" << ::std::endl
+       << "  }" << ::std::endl
+       << "}" << ::std::endl
+       << ::std::endl
+       << "See the JSON OUTPUT section in \033[1mbpkg-common-options(1)\033[0m for details on the" << ::std::endl
+       << "overall properties of this format and the semantics of the \033[1mstruct\033[0m" << ::std::endl
+       << "serialization." << ::std::endl
+       << ::std::endl
+       << "The \033[1mfile::type\033[0m member is a distribution-specific value that classifies the" << ::std::endl
+       << "file. For the \033[1mdebian\033[0m distribution the possible values are \033[1mmain.deb\033[0m, \033[1mdev.deb\033[0m," << ::std::endl
+       << "\033[1mdoc.deb\033[0m, \033[1mcommon.deb\033[0m, \033[1mdbgsym.deb\033[0m, \033[1mchanges\033[0m (\033[1m.changes\033[0m file), and \033[1mbuildid\033[0m" << ::std::endl
+       << "(\033[1m.buildid\033[0m file); see Debian Package Mapping for Production" << ::std::endl
+       << "(bpkg#bindist-mapping-debian-produce) for background. For the \033[1mfedora\033[0m" << ::std::endl
+       << "distribution the possible values are \033[1mmain.rpm\033[0m, \033[1mdevel.rpm\033[0m, \033[1mstatic.rpm\033[0m, \033[1mdoc.rpm\033[0m," << ::std::endl
+       << "\033[1mcommon.rpm\033[0m, and \033[1mdebuginfo.rpm\033[0m; see Fedora Package Mapping for Production" << ::std::endl
+       << "(bpkg#bindist-mapping-fedora-produce) for background. For the \033[1marchive\033[0m" << ::std::endl
+       << "distribution this is the archive type (\033[1m--archive-type\033[0m), for example, \033[1mtar.xz\033[0m or" << ::std::endl
+       << "\033[1mzip\033[0m, potentially prefixed with \033[4mkey\033[0m if the \033[1m--archive-split\033[0m functionality is" << ::std::endl
+       << "used, for example, \033[1mdev.tar.xz\033[0m." << ::std::endl
+       << ::std::endl
+       << "The \033[1mpackage::system_version\033[0m and/or \033[1mfile::system_name\033[0m members are absent if not" << ::std::endl
+       << "applicable to the distribution. The \033[1mfile::system_name\033[0m member is also absent if" << ::std::endl
+       << "the file is not a binary package (for example, \033[1m.changes\033[0m and \033[1m.buildid\033[0m files in" << ::std::endl
+       << "the \033[1mdebian\033[0m distribution)." << ::std::endl;
+
+    p = ::bpkg::pkg_bindist_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-bindist\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-bindist.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-bindist\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-bindist-options.hxx b/bpkg/pkg-bindist-options.hxx
new file mode 100644
index 0000000..97b6a3b
--- /dev/null
+++ b/bpkg/pkg-bindist-options.hxx
@@ -0,0 +1,742 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_BINDIST_OPTIONS_HXX
+#define BPKG_PKG_BINDIST_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <map>
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_bindist_common_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_bindist_common_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_bindist_common_options&);
+
+    // Option accessors.
+    //
+    const string&
+    distribution () const;
+
+    bool
+    distribution_specified () const;
+
+    const string&
+    architecture () const;
+
+    bool
+    architecture_specified () const;
+
+    const string&
+    recursive () const;
+
+    bool
+    recursive_specified () const;
+
+    const bool&
+    private_ () const;
+
+    const dir_path&
+    output_root () const;
+
+    bool
+    output_root_specified () const;
+
+    const bool&
+    wipe_output () const;
+
+    const bool&
+    keep_output () const;
+
+    const bool&
+    allow_dependent_config () const;
+
+    const string&
+    os_release_id () const;
+
+    bool
+    os_release_id_specified () const;
+
+    const string&
+    os_release_version_id () const;
+
+    bool
+    os_release_version_id_specified () const;
+
+    const string&
+    os_release_name () const;
+
+    bool
+    os_release_name_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    string distribution_;
+    bool distribution_specified_;
+    string architecture_;
+    bool architecture_specified_;
+    string recursive_;
+    bool recursive_specified_;
+    bool private__;
+    dir_path output_root_;
+    bool output_root_specified_;
+    bool wipe_output_;
+    bool keep_output_;
+    bool allow_dependent_config_;
+    string os_release_id_;
+    bool os_release_id_specified_;
+    string os_release_version_id_;
+    bool os_release_version_id_specified_;
+    string os_release_name_;
+    bool os_release_name_specified_;
+  };
+
+  class pkg_bindist_debian_options
+  {
+    public:
+    pkg_bindist_debian_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_bindist_debian_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    debian_prepare_only () const;
+
+    const string&
+    debian_buildflags () const;
+
+    bool
+    debian_buildflags_specified () const;
+
+    const strings&
+    debian_maint_option () const;
+
+    bool
+    debian_maint_option_specified () const;
+
+    const strings&
+    debian_build_option () const;
+
+    bool
+    debian_build_option_specified () const;
+
+    const string&
+    debian_build_meta () const;
+
+    bool
+    debian_build_meta_specified () const;
+
+    const string&
+    debian_section () const;
+
+    bool
+    debian_section_specified () const;
+
+    const string&
+    debian_priority () const;
+
+    bool
+    debian_priority_specified () const;
+
+    const string&
+    debian_maintainer () const;
+
+    bool
+    debian_maintainer_specified () const;
+
+    const string&
+    debian_architecture () const;
+
+    bool
+    debian_architecture_specified () const;
+
+    const string&
+    debian_main_langdep () const;
+
+    bool
+    debian_main_langdep_specified () const;
+
+    const string&
+    debian_dev_langdep () const;
+
+    bool
+    debian_dev_langdep_specified () const;
+
+    const string&
+    debian_main_extradep () const;
+
+    bool
+    debian_main_extradep_specified () const;
+
+    const string&
+    debian_dev_extradep () const;
+
+    bool
+    debian_dev_extradep_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool debian_prepare_only_;
+    string debian_buildflags_;
+    bool debian_buildflags_specified_;
+    strings debian_maint_option_;
+    bool debian_maint_option_specified_;
+    strings debian_build_option_;
+    bool debian_build_option_specified_;
+    string debian_build_meta_;
+    bool debian_build_meta_specified_;
+    string debian_section_;
+    bool debian_section_specified_;
+    string debian_priority_;
+    bool debian_priority_specified_;
+    string debian_maintainer_;
+    bool debian_maintainer_specified_;
+    string debian_architecture_;
+    bool debian_architecture_specified_;
+    string debian_main_langdep_;
+    bool debian_main_langdep_specified_;
+    string debian_dev_langdep_;
+    bool debian_dev_langdep_specified_;
+    string debian_main_extradep_;
+    bool debian_main_extradep_specified_;
+    string debian_dev_extradep_;
+    bool debian_dev_extradep_specified_;
+  };
+
+  class pkg_bindist_fedora_options
+  {
+    public:
+    pkg_bindist_fedora_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_bindist_fedora_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    fedora_prepare_only () const;
+
+    const string&
+    fedora_buildflags () const;
+
+    bool
+    fedora_buildflags_specified () const;
+
+    const strings&
+    fedora_build_option () const;
+
+    bool
+    fedora_build_option_specified () const;
+
+    const strings&
+    fedora_query_option () const;
+
+    bool
+    fedora_query_option_specified () const;
+
+    const string&
+    fedora_dist_tag () const;
+
+    bool
+    fedora_dist_tag_specified () const;
+
+    const string&
+    fedora_packager () const;
+
+    bool
+    fedora_packager_specified () const;
+
+    const string&
+    fedora_build_arch () const;
+
+    bool
+    fedora_build_arch_specified () const;
+
+    const strings&
+    fedora_main_langreq () const;
+
+    bool
+    fedora_main_langreq_specified () const;
+
+    const strings&
+    fedora_devel_langreq () const;
+
+    bool
+    fedora_devel_langreq_specified () const;
+
+    const strings&
+    fedora_stat_langreq () const;
+
+    bool
+    fedora_stat_langreq_specified () const;
+
+    const strings&
+    fedora_main_extrareq () const;
+
+    bool
+    fedora_main_extrareq_specified () const;
+
+    const strings&
+    fedora_devel_extrareq () const;
+
+    bool
+    fedora_devel_extrareq_specified () const;
+
+    const strings&
+    fedora_stat_extrareq () const;
+
+    bool
+    fedora_stat_extrareq_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool fedora_prepare_only_;
+    string fedora_buildflags_;
+    bool fedora_buildflags_specified_;
+    strings fedora_build_option_;
+    bool fedora_build_option_specified_;
+    strings fedora_query_option_;
+    bool fedora_query_option_specified_;
+    string fedora_dist_tag_;
+    bool fedora_dist_tag_specified_;
+    string fedora_packager_;
+    bool fedora_packager_specified_;
+    string fedora_build_arch_;
+    bool fedora_build_arch_specified_;
+    strings fedora_main_langreq_;
+    bool fedora_main_langreq_specified_;
+    strings fedora_devel_langreq_;
+    bool fedora_devel_langreq_specified_;
+    strings fedora_stat_langreq_;
+    bool fedora_stat_langreq_specified_;
+    strings fedora_main_extrareq_;
+    bool fedora_main_extrareq_specified_;
+    strings fedora_devel_extrareq_;
+    bool fedora_devel_extrareq_specified_;
+    strings fedora_stat_extrareq_;
+    bool fedora_stat_extrareq_specified_;
+  };
+
+  class pkg_bindist_archive_options
+  {
+    public:
+    pkg_bindist_archive_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_bindist_archive_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    archive_prepare_only () const;
+
+    const strings&
+    archive_type () const;
+
+    bool
+    archive_type_specified () const;
+
+    const std::multimap<string, string>&
+    archive_lang () const;
+
+    bool
+    archive_lang_specified () const;
+
+    const std::multimap<string, string>&
+    archive_lang_impl () const;
+
+    bool
+    archive_lang_impl_specified () const;
+
+    const bool&
+    archive_no_cpu () const;
+
+    const bool&
+    archive_no_os () const;
+
+    const string&
+    archive_build_meta () const;
+
+    bool
+    archive_build_meta_specified () const;
+
+    const dir_path&
+    archive_install_root () const;
+
+    bool
+    archive_install_root_specified () const;
+
+    const bool&
+    archive_install_config () const;
+
+    const std::map<string, string>&
+    archive_split () const;
+
+    bool
+    archive_split_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool archive_prepare_only_;
+    strings archive_type_;
+    bool archive_type_specified_;
+    std::multimap<string, string> archive_lang_;
+    bool archive_lang_specified_;
+    std::multimap<string, string> archive_lang_impl_;
+    bool archive_lang_impl_specified_;
+    bool archive_no_cpu_;
+    bool archive_no_os_;
+    string archive_build_meta_;
+    bool archive_build_meta_specified_;
+    dir_path archive_install_root_;
+    bool archive_install_root_specified_;
+    bool archive_install_config_;
+    std::map<string, string> archive_split_;
+    bool archive_split_specified_;
+  };
+
+  class pkg_bindist_options: public ::bpkg::pkg_bindist_common_options,
+    public ::bpkg::pkg_bindist_debian_options,
+    public ::bpkg::pkg_bindist_fedora_options,
+    public ::bpkg::pkg_bindist_archive_options
+  {
+    public:
+    pkg_bindist_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_bindist_options&);
+
+    // Option accessors.
+    //
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_bindist_usage (::std::ostream&,
+                                ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-bindist-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_BINDIST_OPTIONS_HXX
diff --git a/bpkg/pkg-bindist-options.ixx b/bpkg/pkg-bindist-options.ixx
new file mode 100644
index 0000000..3a5ef7c
--- /dev/null
+++ b/bpkg/pkg-bindist-options.ixx
@@ -0,0 +1,537 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_bindist_common_options
+  //
+
+  inline const string& pkg_bindist_common_options::
+  distribution () const
+  {
+    return this->distribution_;
+  }
+
+  inline bool pkg_bindist_common_options::
+  distribution_specified () const
+  {
+    return this->distribution_specified_;
+  }
+
+  inline const string& pkg_bindist_common_options::
+  architecture () const
+  {
+    return this->architecture_;
+  }
+
+  inline bool pkg_bindist_common_options::
+  architecture_specified () const
+  {
+    return this->architecture_specified_;
+  }
+
+  inline const string& pkg_bindist_common_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+
+  inline bool pkg_bindist_common_options::
+  recursive_specified () const
+  {
+    return this->recursive_specified_;
+  }
+
+  inline const bool& pkg_bindist_common_options::
+  private_ () const
+  {
+    return this->private__;
+  }
+
+  inline const dir_path& pkg_bindist_common_options::
+  output_root () const
+  {
+    return this->output_root_;
+  }
+
+  inline bool pkg_bindist_common_options::
+  output_root_specified () const
+  {
+    return this->output_root_specified_;
+  }
+
+  inline const bool& pkg_bindist_common_options::
+  wipe_output () const
+  {
+    return this->wipe_output_;
+  }
+
+  inline const bool& pkg_bindist_common_options::
+  keep_output () const
+  {
+    return this->keep_output_;
+  }
+
+  inline const bool& pkg_bindist_common_options::
+  allow_dependent_config () const
+  {
+    return this->allow_dependent_config_;
+  }
+
+  inline const string& pkg_bindist_common_options::
+  os_release_id () const
+  {
+    return this->os_release_id_;
+  }
+
+  inline bool pkg_bindist_common_options::
+  os_release_id_specified () const
+  {
+    return this->os_release_id_specified_;
+  }
+
+  inline const string& pkg_bindist_common_options::
+  os_release_version_id () const
+  {
+    return this->os_release_version_id_;
+  }
+
+  inline bool pkg_bindist_common_options::
+  os_release_version_id_specified () const
+  {
+    return this->os_release_version_id_specified_;
+  }
+
+  inline const string& pkg_bindist_common_options::
+  os_release_name () const
+  {
+    return this->os_release_name_;
+  }
+
+  inline bool pkg_bindist_common_options::
+  os_release_name_specified () const
+  {
+    return this->os_release_name_specified_;
+  }
+
+  // pkg_bindist_debian_options
+  //
+
+  inline const bool& pkg_bindist_debian_options::
+  debian_prepare_only () const
+  {
+    return this->debian_prepare_only_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_buildflags () const
+  {
+    return this->debian_buildflags_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_buildflags_specified () const
+  {
+    return this->debian_buildflags_specified_;
+  }
+
+  inline const strings& pkg_bindist_debian_options::
+  debian_maint_option () const
+  {
+    return this->debian_maint_option_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_maint_option_specified () const
+  {
+    return this->debian_maint_option_specified_;
+  }
+
+  inline const strings& pkg_bindist_debian_options::
+  debian_build_option () const
+  {
+    return this->debian_build_option_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_build_option_specified () const
+  {
+    return this->debian_build_option_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_build_meta () const
+  {
+    return this->debian_build_meta_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_build_meta_specified () const
+  {
+    return this->debian_build_meta_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_section () const
+  {
+    return this->debian_section_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_section_specified () const
+  {
+    return this->debian_section_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_priority () const
+  {
+    return this->debian_priority_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_priority_specified () const
+  {
+    return this->debian_priority_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_maintainer () const
+  {
+    return this->debian_maintainer_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_maintainer_specified () const
+  {
+    return this->debian_maintainer_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_architecture () const
+  {
+    return this->debian_architecture_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_architecture_specified () const
+  {
+    return this->debian_architecture_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_main_langdep () const
+  {
+    return this->debian_main_langdep_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_main_langdep_specified () const
+  {
+    return this->debian_main_langdep_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_dev_langdep () const
+  {
+    return this->debian_dev_langdep_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_dev_langdep_specified () const
+  {
+    return this->debian_dev_langdep_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_main_extradep () const
+  {
+    return this->debian_main_extradep_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_main_extradep_specified () const
+  {
+    return this->debian_main_extradep_specified_;
+  }
+
+  inline const string& pkg_bindist_debian_options::
+  debian_dev_extradep () const
+  {
+    return this->debian_dev_extradep_;
+  }
+
+  inline bool pkg_bindist_debian_options::
+  debian_dev_extradep_specified () const
+  {
+    return this->debian_dev_extradep_specified_;
+  }
+
+  // pkg_bindist_fedora_options
+  //
+
+  inline const bool& pkg_bindist_fedora_options::
+  fedora_prepare_only () const
+  {
+    return this->fedora_prepare_only_;
+  }
+
+  inline const string& pkg_bindist_fedora_options::
+  fedora_buildflags () const
+  {
+    return this->fedora_buildflags_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_buildflags_specified () const
+  {
+    return this->fedora_buildflags_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_build_option () const
+  {
+    return this->fedora_build_option_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_build_option_specified () const
+  {
+    return this->fedora_build_option_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_query_option () const
+  {
+    return this->fedora_query_option_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_query_option_specified () const
+  {
+    return this->fedora_query_option_specified_;
+  }
+
+  inline const string& pkg_bindist_fedora_options::
+  fedora_dist_tag () const
+  {
+    return this->fedora_dist_tag_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_dist_tag_specified () const
+  {
+    return this->fedora_dist_tag_specified_;
+  }
+
+  inline const string& pkg_bindist_fedora_options::
+  fedora_packager () const
+  {
+    return this->fedora_packager_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_packager_specified () const
+  {
+    return this->fedora_packager_specified_;
+  }
+
+  inline const string& pkg_bindist_fedora_options::
+  fedora_build_arch () const
+  {
+    return this->fedora_build_arch_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_build_arch_specified () const
+  {
+    return this->fedora_build_arch_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_main_langreq () const
+  {
+    return this->fedora_main_langreq_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_main_langreq_specified () const
+  {
+    return this->fedora_main_langreq_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_devel_langreq () const
+  {
+    return this->fedora_devel_langreq_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_devel_langreq_specified () const
+  {
+    return this->fedora_devel_langreq_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_stat_langreq () const
+  {
+    return this->fedora_stat_langreq_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_stat_langreq_specified () const
+  {
+    return this->fedora_stat_langreq_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_main_extrareq () const
+  {
+    return this->fedora_main_extrareq_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_main_extrareq_specified () const
+  {
+    return this->fedora_main_extrareq_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_devel_extrareq () const
+  {
+    return this->fedora_devel_extrareq_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_devel_extrareq_specified () const
+  {
+    return this->fedora_devel_extrareq_specified_;
+  }
+
+  inline const strings& pkg_bindist_fedora_options::
+  fedora_stat_extrareq () const
+  {
+    return this->fedora_stat_extrareq_;
+  }
+
+  inline bool pkg_bindist_fedora_options::
+  fedora_stat_extrareq_specified () const
+  {
+    return this->fedora_stat_extrareq_specified_;
+  }
+
+  // pkg_bindist_archive_options
+  //
+
+  inline const bool& pkg_bindist_archive_options::
+  archive_prepare_only () const
+  {
+    return this->archive_prepare_only_;
+  }
+
+  inline const strings& pkg_bindist_archive_options::
+  archive_type () const
+  {
+    return this->archive_type_;
+  }
+
+  inline bool pkg_bindist_archive_options::
+  archive_type_specified () const
+  {
+    return this->archive_type_specified_;
+  }
+
+  inline const std::multimap<string, string>& pkg_bindist_archive_options::
+  archive_lang () const
+  {
+    return this->archive_lang_;
+  }
+
+  inline bool pkg_bindist_archive_options::
+  archive_lang_specified () const
+  {
+    return this->archive_lang_specified_;
+  }
+
+  inline const std::multimap<string, string>& pkg_bindist_archive_options::
+  archive_lang_impl () const
+  {
+    return this->archive_lang_impl_;
+  }
+
+  inline bool pkg_bindist_archive_options::
+  archive_lang_impl_specified () const
+  {
+    return this->archive_lang_impl_specified_;
+  }
+
+  inline const bool& pkg_bindist_archive_options::
+  archive_no_cpu () const
+  {
+    return this->archive_no_cpu_;
+  }
+
+  inline const bool& pkg_bindist_archive_options::
+  archive_no_os () const
+  {
+    return this->archive_no_os_;
+  }
+
+  inline const string& pkg_bindist_archive_options::
+  archive_build_meta () const
+  {
+    return this->archive_build_meta_;
+  }
+
+  inline bool pkg_bindist_archive_options::
+  archive_build_meta_specified () const
+  {
+    return this->archive_build_meta_specified_;
+  }
+
+  inline const dir_path& pkg_bindist_archive_options::
+  archive_install_root () const
+  {
+    return this->archive_install_root_;
+  }
+
+  inline bool pkg_bindist_archive_options::
+  archive_install_root_specified () const
+  {
+    return this->archive_install_root_specified_;
+  }
+
+  inline const bool& pkg_bindist_archive_options::
+  archive_install_config () const
+  {
+    return this->archive_install_config_;
+  }
+
+  inline const std::map<string, string>& pkg_bindist_archive_options::
+  archive_split () const
+  {
+    return this->archive_split_;
+  }
+
+  inline bool pkg_bindist_archive_options::
+  archive_split_specified () const
+  {
+    return this->archive_split_specified_;
+  }
+
+  // pkg_bindist_options
+  //
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-build-options.cxx b/bpkg/pkg-build-options.cxx
new file mode 100644
index 0000000..20d04f7
--- /dev/null
+++ b/bpkg/pkg-build-options.cxx
@@ -0,0 +1,1846 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-build-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_build_pkg_options
+  //
+
+  pkg_build_pkg_options::
+  pkg_build_pkg_options ()
+  : upgrade_ (),
+    patch_ (),
+    deorphan_ (),
+    immediate_ (),
+    recursive_ (),
+    upgrade_immediate_ (),
+    patch_immediate_ (),
+    deorphan_immediate_ (),
+    upgrade_recursive_ (),
+    patch_recursive_ (),
+    deorphan_recursive_ (),
+    dependency_ (),
+    keep_out_ (),
+    disfigure_ (),
+    checkout_root_ (),
+    checkout_root_specified_ (false),
+    checkout_purge_ (),
+    config_name_ (),
+    config_name_specified_ (false),
+    config_id_ (),
+    config_id_specified_ (false),
+    config_uuid_ (),
+    config_uuid_specified_ (false)
+  {
+  }
+
+  bool pkg_build_pkg_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_build_pkg_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_build_pkg_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_build_pkg_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_build_pkg_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_build_pkg_options::
+  merge (const pkg_build_pkg_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    if (a.upgrade_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->upgrade_, a.upgrade_);
+    }
+
+    if (a.patch_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->patch_, a.patch_);
+    }
+
+    if (a.deorphan_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->deorphan_, a.deorphan_);
+    }
+
+    if (a.immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->immediate_, a.immediate_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+
+    if (a.upgrade_immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->upgrade_immediate_, a.upgrade_immediate_);
+    }
+
+    if (a.patch_immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->patch_immediate_, a.patch_immediate_);
+    }
+
+    if (a.deorphan_immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->deorphan_immediate_, a.deorphan_immediate_);
+    }
+
+    if (a.upgrade_recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->upgrade_recursive_, a.upgrade_recursive_);
+    }
+
+    if (a.patch_recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->patch_recursive_, a.patch_recursive_);
+    }
+
+    if (a.deorphan_recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->deorphan_recursive_, a.deorphan_recursive_);
+    }
+
+    if (a.dependency_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->dependency_, a.dependency_);
+    }
+
+    if (a.keep_out_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_out_, a.keep_out_);
+    }
+
+    if (a.disfigure_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->disfigure_, a.disfigure_);
+    }
+
+    if (a.checkout_root_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->checkout_root_, a.checkout_root_);
+      this->checkout_root_specified_ = true;
+    }
+
+    if (a.checkout_purge_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->checkout_purge_, a.checkout_purge_);
+    }
+
+    if (a.config_name_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->config_name_, a.config_name_);
+      this->config_name_specified_ = true;
+    }
+
+    if (a.config_id_specified_)
+    {
+      ::bpkg::cli::parser< vector<uint64_t>>::merge (
+        this->config_id_, a.config_id_);
+      this->config_id_specified_ = true;
+    }
+
+    if (a.config_uuid_specified_)
+    {
+      ::bpkg::cli::parser< vector<uuid>>::merge (
+        this->config_uuid_, a.config_uuid_);
+      this->config_uuid_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_build_pkg_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-BUILD PACKAGE OPTIONS\033[0m" << ::std::endl
+       << ::std::endl
+       << "The following options (as well as additional configuration variables) can be" << ::std::endl
+       << "grouped to apply to a specific \033[4mpkg-spec\033[0m as well as specified globally, in which" << ::std::endl
+       << "case they apply to all the specified packages (see \033[1mbpkg-argument-grouping(1)\033[0m" << ::std::endl
+       << "for details)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--upgrade\033[0m|\033[1m-u\033[0m              Upgrade packages to the latest available version that" << ::std::endl
+       << "                          satisfies all the constraints." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--patch\033[0m|\033[1m-p\033[0m                Upgrade packages to the latest available patch" << ::std::endl
+       << "                          version that satisfies all the constraints." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--deorphan\033[0m                Replace orphaned packages with the best matching" << ::std::endl
+       << "                          available package versions which satisfy all the" << ::std::endl
+       << "                          constraints." << ::std::endl
+       << ::std::endl
+       << "                          It may happen that a built package no longer has the" << ::std::endl
+       << "                          corresponding package available in the repository it" << ::std::endl
+       << "                          came from (for example, as a result of" << ::std::endl
+       << "                          \033[1mbpkg-rep-fetch(1)\033[0m or \033[1mbpkg-rep-remove(1)\033[0m). Such a" << ::std::endl
+       << "                          package is called an \033[4morphan\033[0m. Without the \033[1m--deorphan\033[0m" << ::std::endl
+       << "                          option, upgrading, downgrading, or patching an orphan" << ::std::endl
+       << "                          will leave it unchanged if a more suitable version of" << ::std::endl
+       << "                          the package is not available. If the \033[1m--deorphan\033[0m" << ::std::endl
+       << "                          option is specified, then an orphan will be replaced" << ::std::endl
+       << "                          with a non-orphan. In this case, if \033[1m--upgrade\033[0m," << ::std::endl
+       << "                          \033[1m--patch\033[0m, or the package version is specified, then" << ::std::endl
+       << "                          the new version is selected accordingly. Otherwise," << ::std::endl
+       << "                          the closest version to the orphaned version is" << ::std::endl
+       << "                          selected using the following preference order: (1)" << ::std::endl
+       << "                          same version, revision, and iteration, (2) latest" << ::std::endl
+       << "                          iteration of same version and revision, (3) later" << ::std::endl
+       << "                          revision of same version, (4) later patch of same" << ::std::endl
+       << "                          version, (5) later minor of same version, (6) latest" << ::std::endl
+       << "                          available version, including earlier (see Package" << ::std::endl
+       << "                          Version (bpkg#package-version) for details)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--immediate\033[0m|\033[1m-i\033[0m            Also upgrade, patch, or deorphan immediate" << ::std::endl
+       << "                          dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m|\033[1m-r\033[0m            Also upgrade, patch, or deorphan all dependencies," << ::std::endl
+       << "                          recursively." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--upgrade-immediate\033[0m       Upgrade immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--patch-immediate\033[0m         Patch immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--deorphan-immediate\033[0m      Deorphan immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--upgrade-recursive\033[0m       Upgrade all dependencies, recursively." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--patch-recursive\033[0m         Patch all dependencies, recursively." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--deorphan-recursive\033[0m      Deorphan all dependencies, recursively." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--dependency\033[0m              Build, upgrade, or downgrade a package as a" << ::std::endl
+       << "                          dependency rather than to hold." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-out\033[0m                Keep output directories of external packages between" << ::std::endl
+       << "                          upgrades and downgrades. Refer to" << ::std::endl
+       << "                          \033[1mbpkg-pkg-disfigure(1)\033[0m for details." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--disfigure\033[0m               Disfigure packages between upgrades and downgrades" << ::std::endl
+       << "                          effectively causing a from-scratch reconfiguration." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--checkout-root\033[0m \033[4mdir\033[0m       Check out packages that come from version" << ::std::endl
+       << "                          control-based repositories into the specified" << ::std::endl
+       << "                          directory rather than into the configuration" << ::std::endl
+       << "                          directory. Refer to the \033[1m--output-root\033[0m option in" << ::std::endl
+       << "                          \033[1mbpkg-pkg-checkout(1)\033[0m for details." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--checkout-purge\033[0m          Remove the checked out package (source) directories" << ::std::endl
+       << "                          when the packages are purged. Refer to the" << ::std::endl
+       << "                          \033[1m--output-purge\033[0m option in \033[1mbpkg-pkg-checkout(1)\033[0m for" << ::std::endl
+       << "                          details." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--config-name\033[0m \033[4mname\033[0m        Name of the linked configuration to build this" << ::std::endl
+       << "                          package(s) in. By default, the package is built in" << ::std::endl
+       << "                          the current configuration. Repeat this option to" << ::std::endl
+       << "                          specify multiple configurations." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--config-id\033[0m \033[4mnum\033[0m           Numeric id of the linked configuration to build this" << ::std::endl
+       << "                          package(s) in. By default, the package is built in" << ::std::endl
+       << "                          the current configuration. Repeat this option to" << ::std::endl
+       << "                          specify multiple configurations." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--config-uuid\033[0m \033[4muuid\033[0m        UUID of the linked configuration to build this" << ::std::endl
+       << "                          package(s) in. By default, the package is built in" << ::std::endl
+       << "                          the current configuration. Repeat this this option to" << ::std::endl
+       << "                          specify multiple configurations." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_build_pkg_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_build_pkg_options_map;
+
+  static _cli_pkg_build_pkg_options_map _cli_pkg_build_pkg_options_map_;
+
+  struct _cli_pkg_build_pkg_options_map_init
+  {
+    _cli_pkg_build_pkg_options_map_init ()
+    {
+      _cli_pkg_build_pkg_options_map_["--upgrade"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::upgrade_ >;
+      _cli_pkg_build_pkg_options_map_["-u"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::upgrade_ >;
+      _cli_pkg_build_pkg_options_map_["--patch"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::patch_ >;
+      _cli_pkg_build_pkg_options_map_["-p"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::patch_ >;
+      _cli_pkg_build_pkg_options_map_["--deorphan"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::deorphan_ >;
+      _cli_pkg_build_pkg_options_map_["--immediate"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::immediate_ >;
+      _cli_pkg_build_pkg_options_map_["-i"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::immediate_ >;
+      _cli_pkg_build_pkg_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::recursive_ >;
+      _cli_pkg_build_pkg_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::recursive_ >;
+      _cli_pkg_build_pkg_options_map_["--upgrade-immediate"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::upgrade_immediate_ >;
+      _cli_pkg_build_pkg_options_map_["--patch-immediate"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::patch_immediate_ >;
+      _cli_pkg_build_pkg_options_map_["--deorphan-immediate"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::deorphan_immediate_ >;
+      _cli_pkg_build_pkg_options_map_["--upgrade-recursive"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::upgrade_recursive_ >;
+      _cli_pkg_build_pkg_options_map_["--patch-recursive"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::patch_recursive_ >;
+      _cli_pkg_build_pkg_options_map_["--deorphan-recursive"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::deorphan_recursive_ >;
+      _cli_pkg_build_pkg_options_map_["--dependency"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::dependency_ >;
+      _cli_pkg_build_pkg_options_map_["--keep-out"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::keep_out_ >;
+      _cli_pkg_build_pkg_options_map_["--disfigure"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::disfigure_ >;
+      _cli_pkg_build_pkg_options_map_["--checkout-root"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, dir_path, &pkg_build_pkg_options::checkout_root_,
+        &pkg_build_pkg_options::checkout_root_specified_ >;
+      _cli_pkg_build_pkg_options_map_["--checkout-purge"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, &pkg_build_pkg_options::checkout_purge_ >;
+      _cli_pkg_build_pkg_options_map_["--config-name"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, strings, &pkg_build_pkg_options::config_name_,
+        &pkg_build_pkg_options::config_name_specified_ >;
+      _cli_pkg_build_pkg_options_map_["--config-id"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, vector<uint64_t>, &pkg_build_pkg_options::config_id_,
+        &pkg_build_pkg_options::config_id_specified_ >;
+      _cli_pkg_build_pkg_options_map_["--config-uuid"] =
+      &::bpkg::cli::thunk< pkg_build_pkg_options, vector<uuid>, &pkg_build_pkg_options::config_uuid_,
+        &pkg_build_pkg_options::config_uuid_specified_ >;
+    }
+  };
+
+  static _cli_pkg_build_pkg_options_map_init _cli_pkg_build_pkg_options_map_init_;
+
+  bool pkg_build_pkg_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_build_pkg_options_map::const_iterator i (_cli_pkg_build_pkg_options_map_.find (o));
+
+    if (i != _cli_pkg_build_pkg_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    return false;
+  }
+
+  bool pkg_build_pkg_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+
+  // pkg_build_options
+  //
+
+  pkg_build_options::
+  pkg_build_options ()
+  : yes_ (),
+    for__ (),
+    for__specified_ (false),
+    keep_unused_ (),
+    update_dependent_ (),
+    leave_dependent_ (),
+    configure_only_ (),
+    print_only_ (),
+    plan_ (),
+    plan_specified_ (false),
+    no_fetch_ (),
+    fetch_shallow_ (),
+    mask_repository_ (),
+    mask_repository_specified_ (false),
+    mask_repository_uuid_ (),
+    mask_repository_uuid_specified_ (false),
+    no_refinement_ (),
+    no_move_ (),
+    noop_exit_ (),
+    noop_exit_specified_ (false),
+    rebuild_checksum_ (),
+    rebuild_checksum_specified_ (false),
+    no_private_config_ (),
+    no_private_config_specified_ (false),
+    sys_no_query_ (),
+    sys_install_ (),
+    sys_no_fetch_ (),
+    sys_no_stub_ (),
+    sys_yes_ (),
+    sys_sudo_ ("sudo"),
+    sys_sudo_specified_ (false),
+    sys_distribution_ (),
+    sys_distribution_specified_ (false),
+    sys_architecture_ (),
+    sys_architecture_specified_ (false),
+    directory_ (),
+    directory_specified_ (false)
+  {
+  }
+
+  bool pkg_build_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_build_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_build_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_build_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_build_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_build_options::
+  merge (const pkg_build_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+
+    // pkg_build_pkg_options base
+    //
+    ::bpkg::pkg_build_pkg_options::merge (a);
+
+    if (a.yes_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->yes_, a.yes_);
+    }
+
+    if (a.for__specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->for__, a.for__);
+      this->for__specified_ = true;
+    }
+
+    if (a.keep_unused_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_unused_, a.keep_unused_);
+    }
+
+    if (a.update_dependent_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->update_dependent_, a.update_dependent_);
+    }
+
+    if (a.leave_dependent_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->leave_dependent_, a.leave_dependent_);
+    }
+
+    if (a.configure_only_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->configure_only_, a.configure_only_);
+    }
+
+    if (a.print_only_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->print_only_, a.print_only_);
+    }
+
+    if (a.plan_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->plan_, a.plan_);
+      this->plan_specified_ = true;
+    }
+
+    if (a.no_fetch_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_fetch_, a.no_fetch_);
+    }
+
+    if (a.fetch_shallow_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->fetch_shallow_, a.fetch_shallow_);
+    }
+
+    if (a.mask_repository_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->mask_repository_, a.mask_repository_);
+      this->mask_repository_specified_ = true;
+    }
+
+    if (a.mask_repository_uuid_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->mask_repository_uuid_, a.mask_repository_uuid_);
+      this->mask_repository_uuid_specified_ = true;
+    }
+
+    if (a.no_refinement_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_refinement_, a.no_refinement_);
+    }
+
+    if (a.no_move_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_move_, a.no_move_);
+    }
+
+    if (a.noop_exit_specified_)
+    {
+      ::bpkg::cli::parser< uint16_t>::merge (
+        this->noop_exit_, a.noop_exit_);
+      this->noop_exit_specified_ = true;
+    }
+
+    if (a.rebuild_checksum_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->rebuild_checksum_, a.rebuild_checksum_);
+      this->rebuild_checksum_specified_ = true;
+    }
+
+    if (a.no_private_config_specified_)
+    {
+      ::bpkg::cli::parser< uint16_t>::merge (
+        this->no_private_config_, a.no_private_config_);
+      this->no_private_config_specified_ = true;
+    }
+
+    if (a.sys_no_query_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->sys_no_query_, a.sys_no_query_);
+    }
+
+    if (a.sys_install_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->sys_install_, a.sys_install_);
+    }
+
+    if (a.sys_no_fetch_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->sys_no_fetch_, a.sys_no_fetch_);
+    }
+
+    if (a.sys_no_stub_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->sys_no_stub_, a.sys_no_stub_);
+    }
+
+    if (a.sys_yes_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->sys_yes_, a.sys_yes_);
+    }
+
+    if (a.sys_sudo_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->sys_sudo_, a.sys_sudo_);
+      this->sys_sudo_specified_ = true;
+    }
+
+    if (a.sys_distribution_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->sys_distribution_, a.sys_distribution_);
+      this->sys_distribution_specified_ = true;
+    }
+
+    if (a.sys_architecture_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->sys_architecture_, a.sys_architecture_);
+      this->sys_architecture_specified_ = true;
+    }
+
+    if (a.directory_specified_)
+    {
+      ::bpkg::cli::parser< dir_paths>::merge (
+        this->directory_, a.directory_);
+      this->directory_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_build_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-BUILD GLOBAL OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--yes\033[0m|\033[1m-y\033[0m                  Assume the answer to all prompts is \033[1myes\033[0m. Note that" << ::std::endl
+       << "                          this excludes the system package manager prompts; see" << ::std::endl
+       << "                          \033[1m--sys-yes\033[0m for details." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--for\033[0m|\033[1m-f\033[0m \033[4moperation\033[0m        Instead of the default \033[1mupdate\033[0m build system operation," << ::std::endl
+       << "                          perform the \033[1mupdate-for-\033[0m\033[4moperation\033[0m variant where" << ::std::endl
+       << "                          \033[4moperation\033[0m is normally \033[1minstall\033[0m or \033[1mtest\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-unused\033[0m|\033[1m-K\033[0m          Don't drop dependency packages that were" << ::std::endl
+       << "                          automatically built but will no longer be used." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--update-dependent\033[0m|\033[1m-U\033[0m     Update without confirmation dependent packages that" << ::std::endl
+       << "                          are reconfigured due to their dependencies being" << ::std::endl
+       << "                          upgraded or downgraded." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--leave-dependent\033[0m|\033[1m-L\033[0m      Don't offer to update dependent packages that are" << ::std::endl
+       << "                          reconfigured due to their dependencies being upgraded" << ::std::endl
+       << "                          or downgraded." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--configure-only\033[0m|\033[1m-c\033[0m       Configure all the packages but don't update." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--print-only\033[0m              Print to \033[1mstdout\033[0m what would be done without actually" << ::std::endl
+       << "                          doing anything." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--plan\033[0m \033[4mheader\033[0m             Print the plan (even if \033[1m--yes\033[0m is specified) and start" << ::std::endl
+       << "                          it with the \033[4mheader\033[0m line (unless it is empty)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-fetch\033[0m                Don't fetch repositories specified as part of the" << ::std::endl
+       << "                          build command." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--fetch-shallow\033[0m           Don't re-fetch complement and prerequisite" << ::std::endl
+       << "                          repositories of repositories specified as part of the" << ::std::endl
+       << "                          build command. Refer to the \033[1m--shallow\033[0m option in" << ::std::endl
+       << "                          \033[1mbpkg-rep-fetch(1)\033[0m for details." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--mask-repository\033[0m \033[4mrep\033[0m     For the duration of the command execution pretend the" << ::std::endl
+       << "                          specified repository was removed as if by performing" << ::std::endl
+       << "                          the \033[1mrep-remove\033[0m command. The repository can be" << ::std::endl
+       << "                          specified either as a repository name or as a" << ::std::endl
+       << "                          repository location (URL or a directory path). Note" << ::std::endl
+       << "                          that the repository's complement and prerequisite" << ::std::endl
+       << "                          repositories are also considered masked, recursively," << ::std::endl
+       << "                          unless they are complements and/or prerequisites of" << ::std::endl
+       << "                          other unmasked repositories. Repeat this option to" << ::std::endl
+       << "                          mask multiple repositories." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--mask-repository-uuid\033[0m \033[4mv\033[0m  For the duration of the command execution pretend the" << ::std::endl
+       << "                          specified repository was removed from the specified" << ::std::endl
+       << "                          configuration. Similar to \033[1m--mask-repository\033[0m but only" << ::std::endl
+       << "                          masks the repository in a single configuration. The" << ::std::endl
+       << "                          option value is a key-value pair in the form:" << ::std::endl
+       << ::std::endl
+       << "                          \033[4mconfig-uuid\033[0m\033[1m=\033[0m\033[4mrep\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "                          Repeat this option to mask multiple repositories." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-refinement\033[0m           Don't try to refine the configuration by offering to" << ::std::endl
+       << "                          drop any unused dependencies that were potentially" << ::std::endl
+       << "                          left behind on the previous \033[1mpkg-build\033[0m or \033[1mpkg-drop\033[0m" << ::std::endl
+       << "                          command execution if the command is otherwise a noop" << ::std::endl
+       << "                          (performs no new package builds, upgrades, etc)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-move\033[0m                 Don't move dependency packages between" << ::std::endl
+       << "                          configurations. In this mode the \033[1m--config-*\033[0m options" << ::std::endl
+       << "                          specify packages' current rather than new locations." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--noop-exit\033[0m \033[4mcode\033[0m          Exit with the specified error code if the command" << ::std::endl
+       << "                          execution is a noop (performs no new package builds," << ::std::endl
+       << "                          upgrades, etc)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--rebuild-checksum\033[0m \033[4msum\033[0m    Hash the names, versions, and configurations of all" << ::std::endl
+       << "                          the packages that would be built. If the resulting" << ::std::endl
+       << "                          checksum matches the specified, then exit without" << ::std::endl
+       << "                          building anything (potentially with a special error" << ::std::endl
+       << "                          code specified with the \033[1m--noop-exit\033[0m option)." << ::std::endl
+       << "                          Otherwise, proceed to build as normal. In both cases," << ::std::endl
+       << "                          print the resulting checksum to \033[1mstdout\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-private-config\033[0m \033[4mcode\033[0m  If no configuration of a suitable type is linked to" << ::std::endl
+       << "                          build a build-time dependency, instead of" << ::std::endl
+       << "                          automatically creating a private configuration of" << ::std::endl
+       << "                          this type, exit with the specified error code" << ::std::endl
+       << "                          printing to \033[1mstdout\033[0m the dependency chain starting from" << ::std::endl
+       << "                          the build-time dependency (together with its" << ::std::endl
+       << "                          constraint, if present) and ending with the top-level" << ::std::endl
+       << "                          dependent (together with their configuration" << ::std::endl
+       << "                          directories), one entry per line. For example:" << ::std::endl
+       << ::std::endl
+       << "                          yacc ^1.0.0" << ::std::endl
+       << "                          libbar/1.0.0 /path/to/libbar/cfg/" << ::std::endl
+       << "                          libfoo/1.0.0 /path/to/libfoo/cfg/" << ::std::endl
+       << ::std::endl
+       << "                          See \033[1mbpkg-cfg-create(1)\033[0m for details on linked" << ::std::endl
+       << "                          configurations." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-no-query\033[0m            Do not query the system package manager for the" << ::std::endl
+       << "                          installed versions of packages specified with the" << ::std::endl
+       << "                          \033[1msys\033[0m scheme." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-install\033[0m             Instruct the system package manager to install" << ::std::endl
+       << "                          available versions of packages specified with the" << ::std::endl
+       << "                          \033[1msys\033[0m scheme that are not already installed. See also" << ::std::endl
+       << "                          the \033[1m--sys-no-fetch\033[0m, \033[1m--sys-yes\033[0m, and \033[1m--sys-sudo\033[0m" << ::std::endl
+       << "                          options." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-no-fetch\033[0m            Do not fetch the system package manager metadata" << ::std::endl
+       << "                          before querying for available versions of packages" << ::std::endl
+       << "                          specified with the \033[1msys\033[0m scheme. This option only makes" << ::std::endl
+       << "                          sense together with \033[1m--sys-install\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-no-stub\033[0m             Do no require a stub for packages specified with the" << ::std::endl
+       << "                          \033[1msys\033[0m scheme. Note that this option has effect only if" << ::std::endl
+       << "                          the system package manager interactions are supported" << ::std::endl
+       << "                          and not disabled." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-yes\033[0m                 Assume the answer to the system package manager" << ::std::endl
+       << "                          prompts is \033[1myes\033[0m. Note that system package manager" << ::std::endl
+       << "                          interactions may break your system and you should" << ::std::endl
+       << "                          normally only use this option on throw-away setups" << ::std::endl
+       << "                          (test virtual machines, etc)." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-sudo\033[0m \033[4mprog\033[0m           The \033[1msudo\033[0m program to use for system package manager" << ::std::endl
+       << "                          interactions that normally require administrative" << ::std::endl
+       << "                          privileges (fetch package metadata, install packages," << ::std::endl
+       << "                          etc). If unspecified, \033[1msudo\033[0m is used by default. Pass" << ::std::endl
+       << "                          empty or the special \033[1mfalse\033[0m value to disable the use" << ::std::endl
+       << "                          of the \033[1msudo\033[0m program. Note that the \033[1msudo\033[0m program is" << ::std::endl
+       << "                          normally only needed if the system package" << ::std::endl
+       << "                          installation is enabled with the \033[1m--sys-install\033[0m" << ::std::endl
+       << "                          option." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-distribution\033[0m \033[4mname\033[0m   Alternative system/distribution package manager to" << ::std::endl
+       << "                          interact with. The valid \033[4mname\033[0m values are \033[1mdebian\033[0m" << ::std::endl
+       << "                          (Debian and alike, such as Ubuntu, etc) and \033[1mfedora\033[0m" << ::std::endl
+       << "                          (Fedora and alike, such as RHEL, CentOS, etc). Note" << ::std::endl
+       << "                          that some package managers may only be supported when" << ::std::endl
+       << "                          running on certain host operating systems." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--sys-architecture\033[0m \033[4mname\033[0m   Alternative architecture to use when interacting with" << ::std::endl
+       << "                          the system package manager. The valid \033[4mname\033[0m values are" << ::std::endl
+       << "                          system/distribution package manager-specific. If" << ::std::endl
+       << "                          unspecified, the host architecture is used." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--directory\033[0m|\033[1m-d\033[0m \033[4mdir\033[0m        Assume current configuration is in \033[4mdir\033[0m rather than in" << ::std::endl
+       << "                          the current working directory. Repeat this option to" << ::std::endl
+       << "                          specify multiple current configurations. If multiple" << ::std::endl
+       << "                          configurations are specified, they need not belong to" << ::std::endl
+       << "                          the same linked configuration cluster." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_build_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_build_options_map;
+
+  static _cli_pkg_build_options_map _cli_pkg_build_options_map_;
+
+  struct _cli_pkg_build_options_map_init
+  {
+    _cli_pkg_build_options_map_init ()
+    {
+      _cli_pkg_build_options_map_["--yes"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::yes_ >;
+      _cli_pkg_build_options_map_["-y"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::yes_ >;
+      _cli_pkg_build_options_map_["--for"] =
+      &::bpkg::cli::thunk< pkg_build_options, string, &pkg_build_options::for__,
+        &pkg_build_options::for__specified_ >;
+      _cli_pkg_build_options_map_["-f"] =
+      &::bpkg::cli::thunk< pkg_build_options, string, &pkg_build_options::for__,
+        &pkg_build_options::for__specified_ >;
+      _cli_pkg_build_options_map_["--keep-unused"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::keep_unused_ >;
+      _cli_pkg_build_options_map_["-K"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::keep_unused_ >;
+      _cli_pkg_build_options_map_["--update-dependent"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::update_dependent_ >;
+      _cli_pkg_build_options_map_["-U"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::update_dependent_ >;
+      _cli_pkg_build_options_map_["--leave-dependent"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::leave_dependent_ >;
+      _cli_pkg_build_options_map_["-L"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::leave_dependent_ >;
+      _cli_pkg_build_options_map_["--configure-only"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::configure_only_ >;
+      _cli_pkg_build_options_map_["-c"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::configure_only_ >;
+      _cli_pkg_build_options_map_["--print-only"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::print_only_ >;
+      _cli_pkg_build_options_map_["--plan"] =
+      &::bpkg::cli::thunk< pkg_build_options, string, &pkg_build_options::plan_,
+        &pkg_build_options::plan_specified_ >;
+      _cli_pkg_build_options_map_["--no-fetch"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::no_fetch_ >;
+      _cli_pkg_build_options_map_["--fetch-shallow"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::fetch_shallow_ >;
+      _cli_pkg_build_options_map_["--mask-repository"] =
+      &::bpkg::cli::thunk< pkg_build_options, strings, &pkg_build_options::mask_repository_,
+        &pkg_build_options::mask_repository_specified_ >;
+      _cli_pkg_build_options_map_["--mask-repository-uuid"] =
+      &::bpkg::cli::thunk< pkg_build_options, strings, &pkg_build_options::mask_repository_uuid_,
+        &pkg_build_options::mask_repository_uuid_specified_ >;
+      _cli_pkg_build_options_map_["--no-refinement"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::no_refinement_ >;
+      _cli_pkg_build_options_map_["--no-move"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::no_move_ >;
+      _cli_pkg_build_options_map_["--noop-exit"] =
+      &::bpkg::cli::thunk< pkg_build_options, uint16_t, &pkg_build_options::noop_exit_,
+        &pkg_build_options::noop_exit_specified_ >;
+      _cli_pkg_build_options_map_["--rebuild-checksum"] =
+      &::bpkg::cli::thunk< pkg_build_options, string, &pkg_build_options::rebuild_checksum_,
+        &pkg_build_options::rebuild_checksum_specified_ >;
+      _cli_pkg_build_options_map_["--no-private-config"] =
+      &::bpkg::cli::thunk< pkg_build_options, uint16_t, &pkg_build_options::no_private_config_,
+        &pkg_build_options::no_private_config_specified_ >;
+      _cli_pkg_build_options_map_["--sys-no-query"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::sys_no_query_ >;
+      _cli_pkg_build_options_map_["--sys-install"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::sys_install_ >;
+      _cli_pkg_build_options_map_["--sys-no-fetch"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::sys_no_fetch_ >;
+      _cli_pkg_build_options_map_["--sys-no-stub"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::sys_no_stub_ >;
+      _cli_pkg_build_options_map_["--sys-yes"] =
+      &::bpkg::cli::thunk< pkg_build_options, &pkg_build_options::sys_yes_ >;
+      _cli_pkg_build_options_map_["--sys-sudo"] =
+      &::bpkg::cli::thunk< pkg_build_options, string, &pkg_build_options::sys_sudo_,
+        &pkg_build_options::sys_sudo_specified_ >;
+      _cli_pkg_build_options_map_["--sys-distribution"] =
+      &::bpkg::cli::thunk< pkg_build_options, string, &pkg_build_options::sys_distribution_,
+        &pkg_build_options::sys_distribution_specified_ >;
+      _cli_pkg_build_options_map_["--sys-architecture"] =
+      &::bpkg::cli::thunk< pkg_build_options, string, &pkg_build_options::sys_architecture_,
+        &pkg_build_options::sys_architecture_specified_ >;
+      _cli_pkg_build_options_map_["--directory"] =
+      &::bpkg::cli::thunk< pkg_build_options, dir_paths, &pkg_build_options::directory_,
+        &pkg_build_options::directory_specified_ >;
+      _cli_pkg_build_options_map_["-d"] =
+      &::bpkg::cli::thunk< pkg_build_options, dir_paths, &pkg_build_options::directory_,
+        &pkg_build_options::directory_specified_ >;
+    }
+  };
+
+  static _cli_pkg_build_options_map_init _cli_pkg_build_options_map_init_;
+
+  bool pkg_build_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_build_options_map::const_iterator i (_cli_pkg_build_options_map_.find (o));
+
+    if (i != _cli_pkg_build_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    // pkg_build_pkg_options base
+    //
+    if (::bpkg::pkg_build_pkg_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_build_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_build_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-build\033[0m|\033[1mbuild\033[0m [\033[4moptions\033[0m] [\033[1m--upgrade\033[0m|\033[1m-u\033[0m | \033[1m--patch\033[0m|\033[1m-p\033[0m]" << ::std::endl
+       << "                     [\033[4mcfg-var\033[0m... \033[1m--\033[0m] \033[4mpkg-spec\033[0m..." << ::std::endl
+       << "\033[1mbpkg pkg-build\033[0m|\033[1mbuild\033[0m [\033[4moptions\033[0m]  \033[1m--upgrade\033[0m|\033[1m-u\033[0m | \033[1m--patch\033[0m|\033[1m-p\033[0m" << ::std::endl
+       << "                     [\033[4mcfg-var\033[0m... \033[1m--\033[0m]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[4mpkg-spec\033[0m = [\033[4mflags\033[0m](([\033[4mscheme\033[0m\033[1m:\033[0m]\033[4mpkg\033[0m[\033[4mver-spec\033[0m])\033[1m,\033[0m...[\033[1m@\033[0m\033[4mrep-loc\033[0m] | " << ::std::endl
+       << "                   [\033[1m@\033[0m]\033[4mrep-loc\033[0m                             | " << ::std::endl
+       << "                   \033[4mfile\033[0m                                   | " << ::std::endl
+       << "                   \033[4mdir\033[0m\033[1m/\033[0m)" << ::std::endl
+       << "\033[4mflags\033[0m      = \033[1m?\033[0m" << ::std::endl
+       << "\033[4mscheme\033[0m     = \033[1msys\033[0m" << ::std::endl
+       << "\033[4mver-spec\033[0m   = \033[1m/\033[0m\033[4mversion\033[0m | \033[4mversion-constraint\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-build\033[0m command builds one or more packages including all their" << ::std::endl
+       << "dependencies. Besides building new packages, this command is also used to" << ::std::endl
+       << "upgrade or downgrade packages that are already present in the configuration." << ::std::endl
+       << "And unless the \033[1m--keep-unused\033[0m|\033[1m-K\033[0m\033[0m option is specified, \033[1mpkg-build\033[0m will also drop" << ::std::endl
+       << "dependency packages that would otherwise no longer be used." << ::std::endl
+       << ::std::endl
+       << "The first form (one or more packages are specified) builds new or upgrades (by" << ::std::endl
+       << "default or if \033[1m--upgrade\033[0m is specified) or patches (if \033[1m--patch\033[0m is specified) the" << ::std::endl
+       << "specified packages. The second form (no arguments but either \033[1m--upgrade\033[0m or" << ::std::endl
+       << "\033[1m--patch\033[0m is specified) upgrades or patches all the held packages in the" << ::std::endl
+       << "configuration (see below for details on held package)." << ::std::endl
+       << ::std::endl
+       << "In both forms specifying the \033[1m--immediate\033[0m|\033[1m-i\033[0m\033[0m or \033[1m--recursive\033[0m|\033[1m-r\033[0m\033[0m option causes" << ::std::endl
+       << "\033[1mpkg-build\033[0m to also upgrade or patch the immediate or all dependencies of the" << ::std::endl
+       << "specified (first form) or held (second form) packages, respectively. Note also" << ::std::endl
+       << "that in the first form these options can only be specified with an explicit" << ::std::endl
+       << "\033[1m--upgrade\033[0m or \033[1m--patch\033[0m." << ::std::endl
+       << ::std::endl
+       << "Each package can be specified as just the name (\033[4mpkg\033[0m) with optional version" << ::std::endl
+       << "specification (\033[4mver-spec\033[0m), in which case the source code for the package will be" << ::std::endl
+       << "automatically fetched from one of the configured repositories. See the" << ::std::endl
+       << "\033[1mbpkg-rep-add(1)\033[0m and \033[1mbpkg-rep-fetch(1)\033[0m commands for more information on package" << ::std::endl
+       << "repositories. The version specification (\033[4mver-spec\033[0m) can be either the exact" << ::std::endl
+       << "version in the \033[1m/\033[0m\033[4mversion\033[0m\033[0m form or the version constraint as described in Package" << ::std::endl
+       << "Version Constraint (bpkg#package-version-constraint). If \033[4mver-spec\033[0m is not" << ::std::endl
+       << "specified, then the latest available version will be built. To downgrade, the" << ::std::endl
+       << "desired version must be specified explicitly. For example:" << ::std::endl
+       << ::std::endl
+       << "bpkg build foo libfoo/1.2.3 \"bar < 2.0.0\"" << ::std::endl
+       << ::std::endl
+       << "Alternatively, the package repository location (\033[4mrep-loc\033[0m) can be specified as" << ::std::endl
+       << "part of the build command. In this case, if \033[4mver-spec\033[0m is not specified, then the" << ::std::endl
+       << "latest available from this repository version will be built. For example:" << ::std::endl
+       << ::std::endl
+       << "bpkg build foo,libfoo/1.2.3@https://git.example.org/foo.git#master" << ::std::endl
+       << ::std::endl
+       << "If only the location is specified, then the latest versions of all the packages" << ::std::endl
+       << "available directly from this repository will be built (note that this does not" << ::std::endl
+       << "include packages available from complement repositories). The \033[1m@\033[0m delimiter can" << ::std::endl
+       << "be omitted if the location is a URL. For example:" << ::std::endl
+       << ::std::endl
+       << "bpkg build https://git.example.org/foo.git#master" << ::std::endl
+       << "bpkg build @/path/to/repository/" << ::std::endl
+       << ::std::endl
+       << "A package name (\033[4mpkg\033[0m) can be prefixed with a package scheme (\033[4mscheme\033[0m). Currently" << ::std::endl
+       << "the only recognized scheme is \033[1msys\033[0m which instructs \033[1mpkg-build\033[0m to configure the" << ::std::endl
+       << "package as available from the system rather than building it from source." << ::std::endl
+       << ::std::endl
+       << "The system package version (\033[4mver-spec\033[0m) may not be a version constraint but may" << ::std::endl
+       << "be the special '\033[1m/*\033[0m' value, which indicates that the version should be" << ::std::endl
+       << "considered unknown but satisfying any version constraint. If unspecified, then" << ::std::endl
+       << "\033[1mpkg-build\033[0m will attempt to query the system package manager for the installed" << ::std::endl
+       << "version unless the system package manager is unsupported or this functionality" << ::std::endl
+       << "is disabled with \033[1m--sys-no-query\033[0m, in which case the '\033[1m/*\033[0m' \033[4mver-spec\033[0m is assumed. If" << ::std::endl
+       << "the system package manager is supported, then the automatic installation of an" << ::std::endl
+       << "available package can be requested with the \033[1m--sys-install\033[0m option. Note that if" << ::std::endl
+       << "the version is not explicitly specified, then at least a stub package must be" << ::std::endl
+       << "available from one of the repositories unless the \033[1m--sys-no-stub\033[0m option is" << ::std::endl
+       << "specified." << ::std::endl
+       << ::std::endl
+       << "Finally, a package can be specified as either the path to the package archive" << ::std::endl
+       << "(\033[4mfile\033[0m) or to the package directory (\033[4mdir\033[0m\033[1m/\033[0m; note that it must end with a" << ::std::endl
+       << "directory separator). See the \033[1mbpkg-pkg-fetch(1)\033[0m and \033[1mbpkg-pkg-unpack(1)\033[0m commands" << ::std::endl
+       << "for more information on the semantics of specifying the package as an archive" << ::std::endl
+       << "or a directory." << ::std::endl
+       << ::std::endl
+       << "Additional configuration variables (\033[4mcfg-var\033[0m), if any, should be specified" << ::std::endl
+       << "before packages (\033[4mpkg-spec\033[0m) and should be separated with \033[1m--\033[0m. Such variables are" << ::std::endl
+       << "effective only when configuring and only for packages that were explicitly" << ::std::endl
+       << "specified on the command line (unless global overrides). They can also be" << ::std::endl
+       << "specified to only apply to specific packages using the argument grouping" << ::std::endl
+       << "mechanism discussed below. See \033[1mbpkg-pkg-configure(1)\033[0m for more information on" << ::std::endl
+       << "configuration variables." << ::std::endl
+       << ::std::endl
+       << "By default a package that is specified explicitly on the command line is built" << ::std::endl
+       << "to \033[4mhold\033[0m: it will not be considered for automatic removal if it no longer has" << ::std::endl
+       << "any dependents. Only versions from repositories that were added to the" << ::std::endl
+       << "configuration (\033[1mbpkg-rep-add(1)\033[0m) are considered as available for build to hold." << ::std::endl
+       << ::std::endl
+       << "Alternatively, a package can be built (or, more commonly, upgraded/downgraded)" << ::std::endl
+       << "as a \033[4mdependency\033[0m by specifying the \033[1m?\033[0m flag (\033[4mflags\033[0m) or the \033[1m--dependency\033[0m option." << ::std::endl
+       << "Such a package will only be added to the configuration if it actually has any" << ::std::endl
+       << "dependents and once no longer used, it will be automatically dropped. Only" << ::std::endl
+       << "versions from prerequisite repositories of dependent packages are considered as" << ::std::endl
+       << "available for build as a dependency." << ::std::endl
+       << ::std::endl
+       << "Packages (both built to hold and as dependencies) that are specified with an" << ::std::endl
+       << "explicit package version (\033[4mver-spec\033[0m) or as an archive or directory, will have" << ::std::endl
+       << "their versions held, that is, they will not be automatically upgraded." << ::std::endl
+       << ::std::endl
+       << "As an illustration, let's assume in the following example that the stable" << ::std::endl
+       << "repository contains packages \033[1mfoo\033[0m \033[1m1.0.0\033[0m as well as \033[1mlibfoo\033[0m \033[1m1.0.0\033[0m and \033[1m1.1.0\033[0m while" << ::std::endl
+       << "testing -- \033[1mlibfoo\033[0m \033[1m2.0.0\033[0m, that testing is complemented by stable, and that \033[1mfoo\033[0m" << ::std::endl
+       << "depends on \033[1mlibfoo >= 1.0.0\033[0m:" << ::std::endl
+       << ::std::endl
+       << "bpkg fetch https://example.org/1/testing" << ::std::endl
+       << ::std::endl
+       << "bpkg build foo            # build foo    1.0.0 to hold" << ::std::endl
+       << "                          # build libfoo 1.1.0 as dependency" << ::std::endl
+       << ::std::endl
+       << "bpkg build ?libfoo/1.0.0  # downgrade libfoo 1.0.0 as dependency," << ::std::endl
+       << "                          #           also hold version 1.0.0" << ::std::endl
+       << ::std::endl
+       << "bpkg build ?libfoo/2.0.0  # error: 2.0.0 unavailable in dependent's" << ::std::endl
+       << "                          #        (foo) repository (stable)" << ::std::endl
+       << ::std::endl
+       << "bpkg build libfoo/2.0.0   # upgrade libfoo 2.0.0 to hold," << ::std::endl
+       << "                          #         also hold version 2.0.0" << ::std::endl
+       << ::std::endl
+       << "A package can be built in one of the linked configurations instead of the" << ::std::endl
+       << "current (or host/build system module, for build-time dependencies)" << ::std::endl
+       << "configuration by specifying one of the \033[1m--config-*\033[0m options (see" << ::std::endl
+       << "\033[1mbpkg-cfg-create(1)\033[0m for background on linked configurations). For example:" << ::std::endl
+       << ::std::endl
+       << "bpkg build foo { --config-name=alt-host }+ ?bison" << ::std::endl;
+
+    p = ::bpkg::pkg_build_pkg_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    p = ::bpkg::pkg_build_options::print_usage (os, p);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-build\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-build.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-build\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-build-options.hxx b/bpkg/pkg-build-options.hxx
new file mode 100644
index 0000000..7442120
--- /dev/null
+++ b/bpkg/pkg-build-options.hxx
@@ -0,0 +1,738 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_BUILD_OPTIONS_HXX
+#define BPKG_PKG_BUILD_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class pkg_build_pkg_options
+  {
+    public:
+    pkg_build_pkg_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_build_pkg_options&);
+
+    // Option accessors and modifiers.
+    //
+    const bool&
+    upgrade () const;
+
+    bool&
+    upgrade ();
+
+    void
+    upgrade (const bool&);
+
+    const bool&
+    patch () const;
+
+    bool&
+    patch ();
+
+    void
+    patch (const bool&);
+
+    const bool&
+    deorphan () const;
+
+    bool&
+    deorphan ();
+
+    void
+    deorphan (const bool&);
+
+    const bool&
+    immediate () const;
+
+    bool&
+    immediate ();
+
+    void
+    immediate (const bool&);
+
+    const bool&
+    recursive () const;
+
+    bool&
+    recursive ();
+
+    void
+    recursive (const bool&);
+
+    const bool&
+    upgrade_immediate () const;
+
+    bool&
+    upgrade_immediate ();
+
+    void
+    upgrade_immediate (const bool&);
+
+    const bool&
+    patch_immediate () const;
+
+    bool&
+    patch_immediate ();
+
+    void
+    patch_immediate (const bool&);
+
+    const bool&
+    deorphan_immediate () const;
+
+    bool&
+    deorphan_immediate ();
+
+    void
+    deorphan_immediate (const bool&);
+
+    const bool&
+    upgrade_recursive () const;
+
+    bool&
+    upgrade_recursive ();
+
+    void
+    upgrade_recursive (const bool&);
+
+    const bool&
+    patch_recursive () const;
+
+    bool&
+    patch_recursive ();
+
+    void
+    patch_recursive (const bool&);
+
+    const bool&
+    deorphan_recursive () const;
+
+    bool&
+    deorphan_recursive ();
+
+    void
+    deorphan_recursive (const bool&);
+
+    const bool&
+    dependency () const;
+
+    bool&
+    dependency ();
+
+    void
+    dependency (const bool&);
+
+    const bool&
+    keep_out () const;
+
+    bool&
+    keep_out ();
+
+    void
+    keep_out (const bool&);
+
+    const bool&
+    disfigure () const;
+
+    bool&
+    disfigure ();
+
+    void
+    disfigure (const bool&);
+
+    const dir_path&
+    checkout_root () const;
+
+    dir_path&
+    checkout_root ();
+
+    void
+    checkout_root (const dir_path&);
+
+    bool
+    checkout_root_specified () const;
+
+    void
+    checkout_root_specified (bool);
+
+    const bool&
+    checkout_purge () const;
+
+    bool&
+    checkout_purge ();
+
+    void
+    checkout_purge (const bool&);
+
+    const strings&
+    config_name () const;
+
+    strings&
+    config_name ();
+
+    void
+    config_name (const strings&);
+
+    bool
+    config_name_specified () const;
+
+    void
+    config_name_specified (bool);
+
+    const vector<uint64_t>&
+    config_id () const;
+
+    vector<uint64_t>&
+    config_id ();
+
+    void
+    config_id (const vector<uint64_t>&);
+
+    bool
+    config_id_specified () const;
+
+    void
+    config_id_specified (bool);
+
+    const vector<uuid>&
+    config_uuid () const;
+
+    vector<uuid>&
+    config_uuid ();
+
+    void
+    config_uuid (const vector<uuid>&);
+
+    bool
+    config_uuid_specified () const;
+
+    void
+    config_uuid_specified (bool);
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool upgrade_;
+    bool patch_;
+    bool deorphan_;
+    bool immediate_;
+    bool recursive_;
+    bool upgrade_immediate_;
+    bool patch_immediate_;
+    bool deorphan_immediate_;
+    bool upgrade_recursive_;
+    bool patch_recursive_;
+    bool deorphan_recursive_;
+    bool dependency_;
+    bool keep_out_;
+    bool disfigure_;
+    dir_path checkout_root_;
+    bool checkout_root_specified_;
+    bool checkout_purge_;
+    strings config_name_;
+    bool config_name_specified_;
+    vector<uint64_t> config_id_;
+    bool config_id_specified_;
+    vector<uuid> config_uuid_;
+    bool config_uuid_specified_;
+  };
+
+  class pkg_build_options: public ::bpkg::common_options,
+    public ::bpkg::pkg_build_pkg_options
+  {
+    public:
+    pkg_build_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_build_options&);
+
+    // Option accessors and modifiers.
+    //
+    const bool&
+    yes () const;
+
+    bool&
+    yes ();
+
+    void
+    yes (const bool&);
+
+    const string&
+    for_ () const;
+
+    string&
+    for_ ();
+
+    void
+    for_ (const string&);
+
+    bool
+    for__specified () const;
+
+    void
+    for__specified (bool);
+
+    const bool&
+    keep_unused () const;
+
+    bool&
+    keep_unused ();
+
+    void
+    keep_unused (const bool&);
+
+    const bool&
+    update_dependent () const;
+
+    bool&
+    update_dependent ();
+
+    void
+    update_dependent (const bool&);
+
+    const bool&
+    leave_dependent () const;
+
+    bool&
+    leave_dependent ();
+
+    void
+    leave_dependent (const bool&);
+
+    const bool&
+    configure_only () const;
+
+    bool&
+    configure_only ();
+
+    void
+    configure_only (const bool&);
+
+    const bool&
+    print_only () const;
+
+    bool&
+    print_only ();
+
+    void
+    print_only (const bool&);
+
+    const string&
+    plan () const;
+
+    string&
+    plan ();
+
+    void
+    plan (const string&);
+
+    bool
+    plan_specified () const;
+
+    void
+    plan_specified (bool);
+
+    const bool&
+    no_fetch () const;
+
+    bool&
+    no_fetch ();
+
+    void
+    no_fetch (const bool&);
+
+    const bool&
+    fetch_shallow () const;
+
+    bool&
+    fetch_shallow ();
+
+    void
+    fetch_shallow (const bool&);
+
+    const strings&
+    mask_repository () const;
+
+    strings&
+    mask_repository ();
+
+    void
+    mask_repository (const strings&);
+
+    bool
+    mask_repository_specified () const;
+
+    void
+    mask_repository_specified (bool);
+
+    const strings&
+    mask_repository_uuid () const;
+
+    strings&
+    mask_repository_uuid ();
+
+    void
+    mask_repository_uuid (const strings&);
+
+    bool
+    mask_repository_uuid_specified () const;
+
+    void
+    mask_repository_uuid_specified (bool);
+
+    const bool&
+    no_refinement () const;
+
+    bool&
+    no_refinement ();
+
+    void
+    no_refinement (const bool&);
+
+    const bool&
+    no_move () const;
+
+    bool&
+    no_move ();
+
+    void
+    no_move (const bool&);
+
+    const uint16_t&
+    noop_exit () const;
+
+    uint16_t&
+    noop_exit ();
+
+    void
+    noop_exit (const uint16_t&);
+
+    bool
+    noop_exit_specified () const;
+
+    void
+    noop_exit_specified (bool);
+
+    const string&
+    rebuild_checksum () const;
+
+    string&
+    rebuild_checksum ();
+
+    void
+    rebuild_checksum (const string&);
+
+    bool
+    rebuild_checksum_specified () const;
+
+    void
+    rebuild_checksum_specified (bool);
+
+    const uint16_t&
+    no_private_config () const;
+
+    uint16_t&
+    no_private_config ();
+
+    void
+    no_private_config (const uint16_t&);
+
+    bool
+    no_private_config_specified () const;
+
+    void
+    no_private_config_specified (bool);
+
+    const bool&
+    sys_no_query () const;
+
+    bool&
+    sys_no_query ();
+
+    void
+    sys_no_query (const bool&);
+
+    const bool&
+    sys_install () const;
+
+    bool&
+    sys_install ();
+
+    void
+    sys_install (const bool&);
+
+    const bool&
+    sys_no_fetch () const;
+
+    bool&
+    sys_no_fetch ();
+
+    void
+    sys_no_fetch (const bool&);
+
+    const bool&
+    sys_no_stub () const;
+
+    bool&
+    sys_no_stub ();
+
+    void
+    sys_no_stub (const bool&);
+
+    const bool&
+    sys_yes () const;
+
+    bool&
+    sys_yes ();
+
+    void
+    sys_yes (const bool&);
+
+    const string&
+    sys_sudo () const;
+
+    string&
+    sys_sudo ();
+
+    void
+    sys_sudo (const string&);
+
+    bool
+    sys_sudo_specified () const;
+
+    void
+    sys_sudo_specified (bool);
+
+    const string&
+    sys_distribution () const;
+
+    string&
+    sys_distribution ();
+
+    void
+    sys_distribution (const string&);
+
+    bool
+    sys_distribution_specified () const;
+
+    void
+    sys_distribution_specified (bool);
+
+    const string&
+    sys_architecture () const;
+
+    string&
+    sys_architecture ();
+
+    void
+    sys_architecture (const string&);
+
+    bool
+    sys_architecture_specified () const;
+
+    void
+    sys_architecture_specified (bool);
+
+    const dir_paths&
+    directory () const;
+
+    dir_paths&
+    directory ();
+
+    void
+    directory (const dir_paths&);
+
+    bool
+    directory_specified () const;
+
+    void
+    directory_specified (bool);
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool yes_;
+    string for__;
+    bool for__specified_;
+    bool keep_unused_;
+    bool update_dependent_;
+    bool leave_dependent_;
+    bool configure_only_;
+    bool print_only_;
+    string plan_;
+    bool plan_specified_;
+    bool no_fetch_;
+    bool fetch_shallow_;
+    strings mask_repository_;
+    bool mask_repository_specified_;
+    strings mask_repository_uuid_;
+    bool mask_repository_uuid_specified_;
+    bool no_refinement_;
+    bool no_move_;
+    uint16_t noop_exit_;
+    bool noop_exit_specified_;
+    string rebuild_checksum_;
+    bool rebuild_checksum_specified_;
+    uint16_t no_private_config_;
+    bool no_private_config_specified_;
+    bool sys_no_query_;
+    bool sys_install_;
+    bool sys_no_fetch_;
+    bool sys_no_stub_;
+    bool sys_yes_;
+    string sys_sudo_;
+    bool sys_sudo_specified_;
+    string sys_distribution_;
+    bool sys_distribution_specified_;
+    string sys_architecture_;
+    bool sys_architecture_specified_;
+    dir_paths directory_;
+    bool directory_specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_build_usage (::std::ostream&,
+                              ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-build-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_BUILD_OPTIONS_HXX
diff --git a/bpkg/pkg-build-options.ixx b/bpkg/pkg-build-options.ixx
new file mode 100644
index 0000000..7b0da30
--- /dev/null
+++ b/bpkg/pkg-build-options.ixx
@@ -0,0 +1,1014 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_build_pkg_options
+  //
+
+  inline const bool& pkg_build_pkg_options::
+  upgrade () const
+  {
+    return this->upgrade_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  upgrade ()
+  {
+    return this->upgrade_;
+  }
+
+  inline void pkg_build_pkg_options::
+  upgrade (const bool& x)
+  {
+    this->upgrade_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  patch () const
+  {
+    return this->patch_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  patch ()
+  {
+    return this->patch_;
+  }
+
+  inline void pkg_build_pkg_options::
+  patch (const bool& x)
+  {
+    this->patch_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  deorphan () const
+  {
+    return this->deorphan_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  deorphan ()
+  {
+    return this->deorphan_;
+  }
+
+  inline void pkg_build_pkg_options::
+  deorphan (const bool& x)
+  {
+    this->deorphan_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  immediate () const
+  {
+    return this->immediate_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  immediate ()
+  {
+    return this->immediate_;
+  }
+
+  inline void pkg_build_pkg_options::
+  immediate (const bool& x)
+  {
+    this->immediate_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  recursive ()
+  {
+    return this->recursive_;
+  }
+
+  inline void pkg_build_pkg_options::
+  recursive (const bool& x)
+  {
+    this->recursive_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  upgrade_immediate () const
+  {
+    return this->upgrade_immediate_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  upgrade_immediate ()
+  {
+    return this->upgrade_immediate_;
+  }
+
+  inline void pkg_build_pkg_options::
+  upgrade_immediate (const bool& x)
+  {
+    this->upgrade_immediate_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  patch_immediate () const
+  {
+    return this->patch_immediate_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  patch_immediate ()
+  {
+    return this->patch_immediate_;
+  }
+
+  inline void pkg_build_pkg_options::
+  patch_immediate (const bool& x)
+  {
+    this->patch_immediate_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  deorphan_immediate () const
+  {
+    return this->deorphan_immediate_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  deorphan_immediate ()
+  {
+    return this->deorphan_immediate_;
+  }
+
+  inline void pkg_build_pkg_options::
+  deorphan_immediate (const bool& x)
+  {
+    this->deorphan_immediate_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  upgrade_recursive () const
+  {
+    return this->upgrade_recursive_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  upgrade_recursive ()
+  {
+    return this->upgrade_recursive_;
+  }
+
+  inline void pkg_build_pkg_options::
+  upgrade_recursive (const bool& x)
+  {
+    this->upgrade_recursive_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  patch_recursive () const
+  {
+    return this->patch_recursive_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  patch_recursive ()
+  {
+    return this->patch_recursive_;
+  }
+
+  inline void pkg_build_pkg_options::
+  patch_recursive (const bool& x)
+  {
+    this->patch_recursive_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  deorphan_recursive () const
+  {
+    return this->deorphan_recursive_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  deorphan_recursive ()
+  {
+    return this->deorphan_recursive_;
+  }
+
+  inline void pkg_build_pkg_options::
+  deorphan_recursive (const bool& x)
+  {
+    this->deorphan_recursive_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  dependency () const
+  {
+    return this->dependency_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  dependency ()
+  {
+    return this->dependency_;
+  }
+
+  inline void pkg_build_pkg_options::
+  dependency (const bool& x)
+  {
+    this->dependency_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  keep_out () const
+  {
+    return this->keep_out_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  keep_out ()
+  {
+    return this->keep_out_;
+  }
+
+  inline void pkg_build_pkg_options::
+  keep_out (const bool& x)
+  {
+    this->keep_out_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  disfigure () const
+  {
+    return this->disfigure_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  disfigure ()
+  {
+    return this->disfigure_;
+  }
+
+  inline void pkg_build_pkg_options::
+  disfigure (const bool& x)
+  {
+    this->disfigure_ = x;
+  }
+
+  inline const dir_path& pkg_build_pkg_options::
+  checkout_root () const
+  {
+    return this->checkout_root_;
+  }
+
+  inline dir_path& pkg_build_pkg_options::
+  checkout_root ()
+  {
+    return this->checkout_root_;
+  }
+
+  inline void pkg_build_pkg_options::
+  checkout_root (const dir_path& x)
+  {
+    this->checkout_root_ = x;
+  }
+
+  inline bool pkg_build_pkg_options::
+  checkout_root_specified () const
+  {
+    return this->checkout_root_specified_;
+  }
+
+  inline void pkg_build_pkg_options::
+  checkout_root_specified (bool x)
+  {
+    this->checkout_root_specified_ = x;
+  }
+
+  inline const bool& pkg_build_pkg_options::
+  checkout_purge () const
+  {
+    return this->checkout_purge_;
+  }
+
+  inline bool& pkg_build_pkg_options::
+  checkout_purge ()
+  {
+    return this->checkout_purge_;
+  }
+
+  inline void pkg_build_pkg_options::
+  checkout_purge (const bool& x)
+  {
+    this->checkout_purge_ = x;
+  }
+
+  inline const strings& pkg_build_pkg_options::
+  config_name () const
+  {
+    return this->config_name_;
+  }
+
+  inline strings& pkg_build_pkg_options::
+  config_name ()
+  {
+    return this->config_name_;
+  }
+
+  inline void pkg_build_pkg_options::
+  config_name (const strings& x)
+  {
+    this->config_name_ = x;
+  }
+
+  inline bool pkg_build_pkg_options::
+  config_name_specified () const
+  {
+    return this->config_name_specified_;
+  }
+
+  inline void pkg_build_pkg_options::
+  config_name_specified (bool x)
+  {
+    this->config_name_specified_ = x;
+  }
+
+  inline const vector<uint64_t>& pkg_build_pkg_options::
+  config_id () const
+  {
+    return this->config_id_;
+  }
+
+  inline vector<uint64_t>& pkg_build_pkg_options::
+  config_id ()
+  {
+    return this->config_id_;
+  }
+
+  inline void pkg_build_pkg_options::
+  config_id (const vector<uint64_t>& x)
+  {
+    this->config_id_ = x;
+  }
+
+  inline bool pkg_build_pkg_options::
+  config_id_specified () const
+  {
+    return this->config_id_specified_;
+  }
+
+  inline void pkg_build_pkg_options::
+  config_id_specified (bool x)
+  {
+    this->config_id_specified_ = x;
+  }
+
+  inline const vector<uuid>& pkg_build_pkg_options::
+  config_uuid () const
+  {
+    return this->config_uuid_;
+  }
+
+  inline vector<uuid>& pkg_build_pkg_options::
+  config_uuid ()
+  {
+    return this->config_uuid_;
+  }
+
+  inline void pkg_build_pkg_options::
+  config_uuid (const vector<uuid>& x)
+  {
+    this->config_uuid_ = x;
+  }
+
+  inline bool pkg_build_pkg_options::
+  config_uuid_specified () const
+  {
+    return this->config_uuid_specified_;
+  }
+
+  inline void pkg_build_pkg_options::
+  config_uuid_specified (bool x)
+  {
+    this->config_uuid_specified_ = x;
+  }
+
+  // pkg_build_options
+  //
+
+  inline const bool& pkg_build_options::
+  yes () const
+  {
+    return this->yes_;
+  }
+
+  inline bool& pkg_build_options::
+  yes ()
+  {
+    return this->yes_;
+  }
+
+  inline void pkg_build_options::
+  yes (const bool& x)
+  {
+    this->yes_ = x;
+  }
+
+  inline const string& pkg_build_options::
+  for_ () const
+  {
+    return this->for__;
+  }
+
+  inline string& pkg_build_options::
+  for_ ()
+  {
+    return this->for__;
+  }
+
+  inline void pkg_build_options::
+  for_ (const string& x)
+  {
+    this->for__ = x;
+  }
+
+  inline bool pkg_build_options::
+  for__specified () const
+  {
+    return this->for__specified_;
+  }
+
+  inline void pkg_build_options::
+  for__specified (bool x)
+  {
+    this->for__specified_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  keep_unused () const
+  {
+    return this->keep_unused_;
+  }
+
+  inline bool& pkg_build_options::
+  keep_unused ()
+  {
+    return this->keep_unused_;
+  }
+
+  inline void pkg_build_options::
+  keep_unused (const bool& x)
+  {
+    this->keep_unused_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  update_dependent () const
+  {
+    return this->update_dependent_;
+  }
+
+  inline bool& pkg_build_options::
+  update_dependent ()
+  {
+    return this->update_dependent_;
+  }
+
+  inline void pkg_build_options::
+  update_dependent (const bool& x)
+  {
+    this->update_dependent_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  leave_dependent () const
+  {
+    return this->leave_dependent_;
+  }
+
+  inline bool& pkg_build_options::
+  leave_dependent ()
+  {
+    return this->leave_dependent_;
+  }
+
+  inline void pkg_build_options::
+  leave_dependent (const bool& x)
+  {
+    this->leave_dependent_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  configure_only () const
+  {
+    return this->configure_only_;
+  }
+
+  inline bool& pkg_build_options::
+  configure_only ()
+  {
+    return this->configure_only_;
+  }
+
+  inline void pkg_build_options::
+  configure_only (const bool& x)
+  {
+    this->configure_only_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  print_only () const
+  {
+    return this->print_only_;
+  }
+
+  inline bool& pkg_build_options::
+  print_only ()
+  {
+    return this->print_only_;
+  }
+
+  inline void pkg_build_options::
+  print_only (const bool& x)
+  {
+    this->print_only_ = x;
+  }
+
+  inline const string& pkg_build_options::
+  plan () const
+  {
+    return this->plan_;
+  }
+
+  inline string& pkg_build_options::
+  plan ()
+  {
+    return this->plan_;
+  }
+
+  inline void pkg_build_options::
+  plan (const string& x)
+  {
+    this->plan_ = x;
+  }
+
+  inline bool pkg_build_options::
+  plan_specified () const
+  {
+    return this->plan_specified_;
+  }
+
+  inline void pkg_build_options::
+  plan_specified (bool x)
+  {
+    this->plan_specified_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  no_fetch () const
+  {
+    return this->no_fetch_;
+  }
+
+  inline bool& pkg_build_options::
+  no_fetch ()
+  {
+    return this->no_fetch_;
+  }
+
+  inline void pkg_build_options::
+  no_fetch (const bool& x)
+  {
+    this->no_fetch_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  fetch_shallow () const
+  {
+    return this->fetch_shallow_;
+  }
+
+  inline bool& pkg_build_options::
+  fetch_shallow ()
+  {
+    return this->fetch_shallow_;
+  }
+
+  inline void pkg_build_options::
+  fetch_shallow (const bool& x)
+  {
+    this->fetch_shallow_ = x;
+  }
+
+  inline const strings& pkg_build_options::
+  mask_repository () const
+  {
+    return this->mask_repository_;
+  }
+
+  inline strings& pkg_build_options::
+  mask_repository ()
+  {
+    return this->mask_repository_;
+  }
+
+  inline void pkg_build_options::
+  mask_repository (const strings& x)
+  {
+    this->mask_repository_ = x;
+  }
+
+  inline bool pkg_build_options::
+  mask_repository_specified () const
+  {
+    return this->mask_repository_specified_;
+  }
+
+  inline void pkg_build_options::
+  mask_repository_specified (bool x)
+  {
+    this->mask_repository_specified_ = x;
+  }
+
+  inline const strings& pkg_build_options::
+  mask_repository_uuid () const
+  {
+    return this->mask_repository_uuid_;
+  }
+
+  inline strings& pkg_build_options::
+  mask_repository_uuid ()
+  {
+    return this->mask_repository_uuid_;
+  }
+
+  inline void pkg_build_options::
+  mask_repository_uuid (const strings& x)
+  {
+    this->mask_repository_uuid_ = x;
+  }
+
+  inline bool pkg_build_options::
+  mask_repository_uuid_specified () const
+  {
+    return this->mask_repository_uuid_specified_;
+  }
+
+  inline void pkg_build_options::
+  mask_repository_uuid_specified (bool x)
+  {
+    this->mask_repository_uuid_specified_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  no_refinement () const
+  {
+    return this->no_refinement_;
+  }
+
+  inline bool& pkg_build_options::
+  no_refinement ()
+  {
+    return this->no_refinement_;
+  }
+
+  inline void pkg_build_options::
+  no_refinement (const bool& x)
+  {
+    this->no_refinement_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  no_move () const
+  {
+    return this->no_move_;
+  }
+
+  inline bool& pkg_build_options::
+  no_move ()
+  {
+    return this->no_move_;
+  }
+
+  inline void pkg_build_options::
+  no_move (const bool& x)
+  {
+    this->no_move_ = x;
+  }
+
+  inline const uint16_t& pkg_build_options::
+  noop_exit () const
+  {
+    return this->noop_exit_;
+  }
+
+  inline uint16_t& pkg_build_options::
+  noop_exit ()
+  {
+    return this->noop_exit_;
+  }
+
+  inline void pkg_build_options::
+  noop_exit (const uint16_t& x)
+  {
+    this->noop_exit_ = x;
+  }
+
+  inline bool pkg_build_options::
+  noop_exit_specified () const
+  {
+    return this->noop_exit_specified_;
+  }
+
+  inline void pkg_build_options::
+  noop_exit_specified (bool x)
+  {
+    this->noop_exit_specified_ = x;
+  }
+
+  inline const string& pkg_build_options::
+  rebuild_checksum () const
+  {
+    return this->rebuild_checksum_;
+  }
+
+  inline string& pkg_build_options::
+  rebuild_checksum ()
+  {
+    return this->rebuild_checksum_;
+  }
+
+  inline void pkg_build_options::
+  rebuild_checksum (const string& x)
+  {
+    this->rebuild_checksum_ = x;
+  }
+
+  inline bool pkg_build_options::
+  rebuild_checksum_specified () const
+  {
+    return this->rebuild_checksum_specified_;
+  }
+
+  inline void pkg_build_options::
+  rebuild_checksum_specified (bool x)
+  {
+    this->rebuild_checksum_specified_ = x;
+  }
+
+  inline const uint16_t& pkg_build_options::
+  no_private_config () const
+  {
+    return this->no_private_config_;
+  }
+
+  inline uint16_t& pkg_build_options::
+  no_private_config ()
+  {
+    return this->no_private_config_;
+  }
+
+  inline void pkg_build_options::
+  no_private_config (const uint16_t& x)
+  {
+    this->no_private_config_ = x;
+  }
+
+  inline bool pkg_build_options::
+  no_private_config_specified () const
+  {
+    return this->no_private_config_specified_;
+  }
+
+  inline void pkg_build_options::
+  no_private_config_specified (bool x)
+  {
+    this->no_private_config_specified_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  sys_no_query () const
+  {
+    return this->sys_no_query_;
+  }
+
+  inline bool& pkg_build_options::
+  sys_no_query ()
+  {
+    return this->sys_no_query_;
+  }
+
+  inline void pkg_build_options::
+  sys_no_query (const bool& x)
+  {
+    this->sys_no_query_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  sys_install () const
+  {
+    return this->sys_install_;
+  }
+
+  inline bool& pkg_build_options::
+  sys_install ()
+  {
+    return this->sys_install_;
+  }
+
+  inline void pkg_build_options::
+  sys_install (const bool& x)
+  {
+    this->sys_install_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  sys_no_fetch () const
+  {
+    return this->sys_no_fetch_;
+  }
+
+  inline bool& pkg_build_options::
+  sys_no_fetch ()
+  {
+    return this->sys_no_fetch_;
+  }
+
+  inline void pkg_build_options::
+  sys_no_fetch (const bool& x)
+  {
+    this->sys_no_fetch_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  sys_no_stub () const
+  {
+    return this->sys_no_stub_;
+  }
+
+  inline bool& pkg_build_options::
+  sys_no_stub ()
+  {
+    return this->sys_no_stub_;
+  }
+
+  inline void pkg_build_options::
+  sys_no_stub (const bool& x)
+  {
+    this->sys_no_stub_ = x;
+  }
+
+  inline const bool& pkg_build_options::
+  sys_yes () const
+  {
+    return this->sys_yes_;
+  }
+
+  inline bool& pkg_build_options::
+  sys_yes ()
+  {
+    return this->sys_yes_;
+  }
+
+  inline void pkg_build_options::
+  sys_yes (const bool& x)
+  {
+    this->sys_yes_ = x;
+  }
+
+  inline const string& pkg_build_options::
+  sys_sudo () const
+  {
+    return this->sys_sudo_;
+  }
+
+  inline string& pkg_build_options::
+  sys_sudo ()
+  {
+    return this->sys_sudo_;
+  }
+
+  inline void pkg_build_options::
+  sys_sudo (const string& x)
+  {
+    this->sys_sudo_ = x;
+  }
+
+  inline bool pkg_build_options::
+  sys_sudo_specified () const
+  {
+    return this->sys_sudo_specified_;
+  }
+
+  inline void pkg_build_options::
+  sys_sudo_specified (bool x)
+  {
+    this->sys_sudo_specified_ = x;
+  }
+
+  inline const string& pkg_build_options::
+  sys_distribution () const
+  {
+    return this->sys_distribution_;
+  }
+
+  inline string& pkg_build_options::
+  sys_distribution ()
+  {
+    return this->sys_distribution_;
+  }
+
+  inline void pkg_build_options::
+  sys_distribution (const string& x)
+  {
+    this->sys_distribution_ = x;
+  }
+
+  inline bool pkg_build_options::
+  sys_distribution_specified () const
+  {
+    return this->sys_distribution_specified_;
+  }
+
+  inline void pkg_build_options::
+  sys_distribution_specified (bool x)
+  {
+    this->sys_distribution_specified_ = x;
+  }
+
+  inline const string& pkg_build_options::
+  sys_architecture () const
+  {
+    return this->sys_architecture_;
+  }
+
+  inline string& pkg_build_options::
+  sys_architecture ()
+  {
+    return this->sys_architecture_;
+  }
+
+  inline void pkg_build_options::
+  sys_architecture (const string& x)
+  {
+    this->sys_architecture_ = x;
+  }
+
+  inline bool pkg_build_options::
+  sys_architecture_specified () const
+  {
+    return this->sys_architecture_specified_;
+  }
+
+  inline void pkg_build_options::
+  sys_architecture_specified (bool x)
+  {
+    this->sys_architecture_specified_ = x;
+  }
+
+  inline const dir_paths& pkg_build_options::
+  directory () const
+  {
+    return this->directory_;
+  }
+
+  inline dir_paths& pkg_build_options::
+  directory ()
+  {
+    return this->directory_;
+  }
+
+  inline void pkg_build_options::
+  directory (const dir_paths& x)
+  {
+    this->directory_ = x;
+  }
+
+  inline bool pkg_build_options::
+  directory_specified () const
+  {
+    return this->directory_specified_;
+  }
+
+  inline void pkg_build_options::
+  directory_specified (bool x)
+  {
+    this->directory_specified_ = x;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-checkout-options.cxx b/bpkg/pkg-checkout-options.cxx
new file mode 100644
index 0000000..b8ad0d9
--- /dev/null
+++ b/bpkg/pkg-checkout-options.cxx
@@ -0,0 +1,728 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-checkout-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_checkout_options
+  //
+
+  pkg_checkout_options::
+  pkg_checkout_options ()
+  : replace_ (),
+    output_root_ (),
+    output_root_specified_ (false),
+    output_purge_ ()
+  {
+  }
+
+  bool pkg_checkout_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_checkout_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_checkout_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_checkout_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_checkout_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_checkout_options::
+  merge (const pkg_checkout_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.replace_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->replace_, a.replace_);
+    }
+
+    if (a.output_root_specified_)
+    {
+      ::bpkg::cli::parser< dir_path>::merge (
+        this->output_root_, a.output_root_);
+      this->output_root_specified_ = true;
+    }
+
+    if (a.output_purge_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->output_purge_, a.output_purge_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_checkout_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-CHECKOUT OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--replace\033[0m|\033[1m-r\033[0m              Replace the source directory if the package is" << ::std::endl
+       << "                          already fetched or unpacked." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--output-root\033[0m \033[4mdir\033[0m         Check out the package into the specified directory" << ::std::endl
+       << "                          rather than into the configuration directory. Note" << ::std::endl
+       << "                          that the package source is placed into the" << ::std::endl
+       << "                          \033[4mpackage\033[0m\033[1m-\033[0m\033[4mversion\033[0m\033[0m subdirectory of this directory." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--output-purge\033[0m            Remove the checked out package (source) directory" << ::std::endl
+       << "                          when the package is purged." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_checkout_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_checkout_options_map;
+
+  static _cli_pkg_checkout_options_map _cli_pkg_checkout_options_map_;
+
+  struct _cli_pkg_checkout_options_map_init
+  {
+    _cli_pkg_checkout_options_map_init ()
+    {
+      _cli_pkg_checkout_options_map_["--replace"] =
+      &::bpkg::cli::thunk< pkg_checkout_options, &pkg_checkout_options::replace_ >;
+      _cli_pkg_checkout_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_checkout_options, &pkg_checkout_options::replace_ >;
+      _cli_pkg_checkout_options_map_["--output-root"] =
+      &::bpkg::cli::thunk< pkg_checkout_options, dir_path, &pkg_checkout_options::output_root_,
+        &pkg_checkout_options::output_root_specified_ >;
+      _cli_pkg_checkout_options_map_["--output-purge"] =
+      &::bpkg::cli::thunk< pkg_checkout_options, &pkg_checkout_options::output_purge_ >;
+    }
+  };
+
+  static _cli_pkg_checkout_options_map_init _cli_pkg_checkout_options_map_init_;
+
+  bool pkg_checkout_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_checkout_options_map::const_iterator i (_cli_pkg_checkout_options_map_.find (o));
+
+    if (i != _cli_pkg_checkout_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_checkout_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_checkout_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-checkout\033[0m [\033[4moptions\033[0m] \033[4mpkg\033[0m\033[1m/\033[0m\033[4mver\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-checkout\033[0m command checks out the specified package version from one of" << ::std::endl
+       << "the version control-based repositories (\033[1mbpkg-rep-add(1)\033[0m). The resulting package" << ::std::endl
+       << "state is \033[1munpacked\033[0m (\033[1mbpkg-pkg-status(1)\033[0m)." << ::std::endl
+       << ::std::endl
+       << "If the \033[1m--output-root\033[0m option is passed, then the package is checked out into the" << ::std::endl
+       << "specified directory rather than into the configuration directory. In this case," << ::std::endl
+       << "\033[1mbpkg\033[0m uses the package (source) directory in place, similar to the \033[1mpkg-unpack" << ::std::endl
+       << "--existing|-e\033[0m mode. Also, unless the \033[1m--output-purge\033[0m option is specified, \033[1mbpkg\033[0m" << ::std::endl
+       << "will not attempt to remove this directory when the package is later purged with" << ::std::endl
+       << "the \033[1mbpkg-pkg-purge(1)\033[0m command. Note also that such a package is not \033[4mexternal\033[0m" << ::std::endl
+       << "(see \033[1mbpkg-pkg-unpack(1)\033[0m for details)." << ::std::endl
+       << ::std::endl
+       << "If the \033[1m--replace|-r\033[0m option is specified, then \033[1mpkg-checkout\033[0m will replace the" << ::std::endl
+       << "archive and/or source directory of a package that is already in the \033[1munpacked\033[0m or" << ::std::endl
+       << "\033[1mfetched\033[0m state." << ::std::endl;
+
+    p = ::bpkg::pkg_checkout_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-checkout\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-checkout.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-checkout\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-checkout-options.hxx b/bpkg/pkg-checkout-options.hxx
new file mode 100644
index 0000000..53ddc1e
--- /dev/null
+++ b/bpkg/pkg-checkout-options.hxx
@@ -0,0 +1,125 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_CHECKOUT_OPTIONS_HXX
+#define BPKG_PKG_CHECKOUT_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_checkout_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_checkout_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_checkout_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    replace () const;
+
+    const dir_path&
+    output_root () const;
+
+    bool
+    output_root_specified () const;
+
+    const bool&
+    output_purge () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool replace_;
+    dir_path output_root_;
+    bool output_root_specified_;
+    bool output_purge_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_checkout_usage (::std::ostream&,
+                                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-checkout-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_CHECKOUT_OPTIONS_HXX
diff --git a/bpkg/pkg-checkout-options.ixx b/bpkg/pkg-checkout-options.ixx
new file mode 100644
index 0000000..af1e0c4
--- /dev/null
+++ b/bpkg/pkg-checkout-options.ixx
@@ -0,0 +1,45 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_checkout_options
+  //
+
+  inline const bool& pkg_checkout_options::
+  replace () const
+  {
+    return this->replace_;
+  }
+
+  inline const dir_path& pkg_checkout_options::
+  output_root () const
+  {
+    return this->output_root_;
+  }
+
+  inline bool pkg_checkout_options::
+  output_root_specified () const
+  {
+    return this->output_root_specified_;
+  }
+
+  inline const bool& pkg_checkout_options::
+  output_purge () const
+  {
+    return this->output_purge_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-clean-options.cxx b/bpkg/pkg-clean-options.cxx
new file mode 100644
index 0000000..482f279
--- /dev/null
+++ b/bpkg/pkg-clean-options.cxx
@@ -0,0 +1,742 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-clean-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_clean_options
+  //
+
+  pkg_clean_options::
+  pkg_clean_options ()
+  : all_ (),
+    all_pattern_ (),
+    all_pattern_specified_ (false),
+    immediate_ (),
+    recursive_ ()
+  {
+  }
+
+  bool pkg_clean_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_clean_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_clean_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_clean_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_clean_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_clean_options::
+  merge (const pkg_clean_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.all_pattern_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->all_pattern_, a.all_pattern_);
+      this->all_pattern_specified_ = true;
+    }
+
+    if (a.immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->immediate_, a.immediate_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_clean_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-CLEAN OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Clean all held packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all-pattern\033[0m \033[4mpattern\033[0m     Clean held packages that match the specified wildcard" << ::std::endl
+       << "                          pattern. Repeat this option to match multiple" << ::std::endl
+       << "                          patterns. Note that you may need to quote the pattern" << ::std::endl
+       << "                          to prevent expansion by your shell." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--immediate\033[0m|\033[1m-i\033[0m            Also clean immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m|\033[1m-r\033[0m            Also clean all dependencies, recursively." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_clean_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_clean_options_map;
+
+  static _cli_pkg_clean_options_map _cli_pkg_clean_options_map_;
+
+  struct _cli_pkg_clean_options_map_init
+  {
+    _cli_pkg_clean_options_map_init ()
+    {
+      _cli_pkg_clean_options_map_["--all"] =
+      &::bpkg::cli::thunk< pkg_clean_options, &pkg_clean_options::all_ >;
+      _cli_pkg_clean_options_map_["-a"] =
+      &::bpkg::cli::thunk< pkg_clean_options, &pkg_clean_options::all_ >;
+      _cli_pkg_clean_options_map_["--all-pattern"] =
+      &::bpkg::cli::thunk< pkg_clean_options, strings, &pkg_clean_options::all_pattern_,
+        &pkg_clean_options::all_pattern_specified_ >;
+      _cli_pkg_clean_options_map_["--immediate"] =
+      &::bpkg::cli::thunk< pkg_clean_options, &pkg_clean_options::immediate_ >;
+      _cli_pkg_clean_options_map_["-i"] =
+      &::bpkg::cli::thunk< pkg_clean_options, &pkg_clean_options::immediate_ >;
+      _cli_pkg_clean_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_clean_options, &pkg_clean_options::recursive_ >;
+      _cli_pkg_clean_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_clean_options, &pkg_clean_options::recursive_ >;
+    }
+  };
+
+  static _cli_pkg_clean_options_map_init _cli_pkg_clean_options_map_init_;
+
+  bool pkg_clean_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_clean_options_map::const_iterator i (_cli_pkg_clean_options_map_.find (o));
+
+    if (i != _cli_pkg_clean_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_clean_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_clean_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-clean\033[0m|\033[1mclean\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[4mpkg\033[0m..." << ::std::endl
+       << "\033[1mbpkg pkg-clean\033[0m|\033[1mclean\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[1m--all\033[0m|\033[1m-a\033[0m" << ::std::endl
+       << "\033[1mbpkg pkg-clean\033[0m|\033[1mclean\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] (\033[1m--all-pattern\033[0m <pattern>)...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-clean\033[0m command cleans the specified packages (the first form), all the" << ::std::endl
+       << "held packages (the second form, see \033[1mbpkg-pkg-status(1)\033[0m), or all the held" << ::std::endl
+       << "packages that match any of the specified wildcard patterns (the third form)." << ::std::endl
+       << "Additionally, immediate or all dependencies of these packages can be also" << ::std::endl
+       << "cleaned by specifying the \033[1m--immediate\033[0m|\033[1m-i\033[0m\033[0m or \033[1m--recursive\033[0m|\033[1m-r\033[0m\033[0m options," << ::std::endl
+       << "respectively. Underneath, this command doesn't do much more than run \033[1mb clean\033[0m." << ::std::endl
+       << "In the first form the specified packages must have been previously configured" << ::std::endl
+       << "with \033[1mbpkg-pkg-build(1)\033[0m or \033[1mbpkg-pkg-configure(1)\033[0m." << ::std::endl
+       << ::std::endl
+       << "Additional command line variables (\033[4mvars\033[0m, normally \033[1mconfig.*\033[0m) can be passed to" << ::std::endl
+       << "the build system. Such variables apply to all the specified packages but can" << ::std::endl
+       << "also be specified to only apply to specific packages using the argument" << ::std::endl
+       << "grouping mechanism (see \033[1mbpkg-argument-grouping(1)\033[0m for details)." << ::std::endl;
+
+    p = ::bpkg::pkg_clean_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-clean\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-clean.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-clean\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-clean-options.hxx b/bpkg/pkg-clean-options.hxx
new file mode 100644
index 0000000..13a1e73
--- /dev/null
+++ b/bpkg/pkg-clean-options.hxx
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_CLEAN_OPTIONS_HXX
+#define BPKG_PKG_CLEAN_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_clean_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_clean_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_clean_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const strings&
+    all_pattern () const;
+
+    bool
+    all_pattern_specified () const;
+
+    const bool&
+    immediate () const;
+
+    const bool&
+    recursive () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    strings all_pattern_;
+    bool all_pattern_specified_;
+    bool immediate_;
+    bool recursive_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_clean_usage (::std::ostream&,
+                              ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-clean-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_CLEAN_OPTIONS_HXX
diff --git a/bpkg/pkg-clean-options.ixx b/bpkg/pkg-clean-options.ixx
new file mode 100644
index 0000000..afa49a1
--- /dev/null
+++ b/bpkg/pkg-clean-options.ixx
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_clean_options
+  //
+
+  inline const bool& pkg_clean_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const strings& pkg_clean_options::
+  all_pattern () const
+  {
+    return this->all_pattern_;
+  }
+
+  inline bool pkg_clean_options::
+  all_pattern_specified () const
+  {
+    return this->all_pattern_specified_;
+  }
+
+  inline const bool& pkg_clean_options::
+  immediate () const
+  {
+    return this->immediate_;
+  }
+
+  inline const bool& pkg_clean_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-configure-options.cxx b/bpkg/pkg-configure-options.cxx
new file mode 100644
index 0000000..8fb31cb
--- /dev/null
+++ b/bpkg/pkg-configure-options.cxx
@@ -0,0 +1,679 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-configure-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_configure_options
+  //
+
+  pkg_configure_options::
+  pkg_configure_options ()
+  {
+  }
+
+  bool pkg_configure_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_configure_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_configure_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_configure_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_configure_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_configure_options::
+  merge (const pkg_configure_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+  }
+
+  ::bpkg::cli::usage_para pkg_configure_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-CONFIGURE OPTIONS\033[0m" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_configure_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_configure_options_map;
+
+  static _cli_pkg_configure_options_map _cli_pkg_configure_options_map_;
+
+  struct _cli_pkg_configure_options_map_init
+  {
+    _cli_pkg_configure_options_map_init ()
+    {
+    }
+  };
+
+  static _cli_pkg_configure_options_map_init _cli_pkg_configure_options_map_init_;
+
+  bool pkg_configure_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_configure_options_map::const_iterator i (_cli_pkg_configure_options_map_.find (o));
+
+    if (i != _cli_pkg_configure_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_configure_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_configure_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-configure\033[0m [\033[4moptions\033[0m] [\033[4mcfg-var\033[0m...] \033[4mpkg\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-configure\033[0m command configures either the previously unpacked" << ::std::endl
+       << "(\033[1mbpkg-pkg-unpack(1)\033[0m, \033[1mbpkg-pkg-checkout(1)\033[0m) source code package or a package" << ::std::endl
+       << "that is present in the system." << ::std::endl
+       << ::std::endl
+       << "A source code package inherits the common \033[1mbuild2\033[0m configuration values that were" << ::std::endl
+       << "specified when creating the configuration (\033[1mbpkg-cfg-create(1)\033[0m). Additional" << ::std::endl
+       << "package-specific configuration variables can be passed to \033[1mpkg-configure\033[0m" << ::std::endl
+       << "(\033[4mcfg-var\033[0m)." << ::std::endl
+       << ::std::endl
+       << "A system package is specified using the \033[1msys:\033[0m\033[4mpkg\033[0m[/\033[4mver\033[0m]\033[0m syntax. If the package" << ::std::endl
+       << "version (\033[4mver\033[0m) is not specified, then it is considered to be unknown but" << ::std::endl
+       << "satisfying any dependency constraint. Such a version is displayed as \033[1m*\033[0m." << ::std::endl;
+
+    p = ::bpkg::pkg_configure_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-configure\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-configure.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-configure\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-configure-options.hxx b/bpkg/pkg-configure-options.hxx
new file mode 100644
index 0000000..e990f9c
--- /dev/null
+++ b/bpkg/pkg-configure-options.hxx
@@ -0,0 +1,109 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_CONFIGURE_OPTIONS_HXX
+#define BPKG_PKG_CONFIGURE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_configure_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_configure_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_configure_options&);
+
+    // Option accessors.
+    //
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_configure_usage (::std::ostream&,
+                                  ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-configure-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_CONFIGURE_OPTIONS_HXX
diff --git a/bpkg/pkg-configure-options.ixx b/bpkg/pkg-configure-options.ixx
new file mode 100644
index 0000000..645428c
--- /dev/null
+++ b/bpkg/pkg-configure-options.ixx
@@ -0,0 +1,21 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_configure_options
+  //
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-disfigure-options.cxx b/bpkg/pkg-disfigure-options.cxx
new file mode 100644
index 0000000..4a15052
--- /dev/null
+++ b/bpkg/pkg-disfigure-options.cxx
@@ -0,0 +1,701 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-disfigure-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_disfigure_options
+  //
+
+  pkg_disfigure_options::
+  pkg_disfigure_options ()
+  : keep_out_ (),
+    keep_config_ ()
+  {
+  }
+
+  bool pkg_disfigure_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_disfigure_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_disfigure_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_disfigure_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_disfigure_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_disfigure_options::
+  merge (const pkg_disfigure_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.keep_out_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_out_, a.keep_out_);
+    }
+
+    if (a.keep_config_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_config_, a.keep_config_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_disfigure_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-DISFIGURE OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-out\033[0m                Don't clean the package's output directory." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-config\033[0m             Don't remove the package's build system configuration" << ::std::endl
+       << "                          (\033[1mconfig.build\033[0m)." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_disfigure_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_disfigure_options_map;
+
+  static _cli_pkg_disfigure_options_map _cli_pkg_disfigure_options_map_;
+
+  struct _cli_pkg_disfigure_options_map_init
+  {
+    _cli_pkg_disfigure_options_map_init ()
+    {
+      _cli_pkg_disfigure_options_map_["--keep-out"] =
+      &::bpkg::cli::thunk< pkg_disfigure_options, &pkg_disfigure_options::keep_out_ >;
+      _cli_pkg_disfigure_options_map_["--keep-config"] =
+      &::bpkg::cli::thunk< pkg_disfigure_options, &pkg_disfigure_options::keep_config_ >;
+    }
+  };
+
+  static _cli_pkg_disfigure_options_map_init _cli_pkg_disfigure_options_map_init_;
+
+  bool pkg_disfigure_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_disfigure_options_map::const_iterator i (_cli_pkg_disfigure_options_map_.find (o));
+
+    if (i != _cli_pkg_disfigure_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_disfigure_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_disfigure_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-disfigure\033[0m [\033[4moptions\033[0m] \033[4mpkg\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-disfigure\033[0m command disfigures the previously configured (via" << ::std::endl
+       << "\033[1mbpkg-pkg-build(1)\033[0m or \033[1mbpkg-pkg-configure(1)\033[0m) package. A source code package is" << ::std::endl
+       << "returned to the \033[1munpacked\033[0m state. A system package is removed from the" << ::std::endl
+       << "configuration." << ::std::endl
+       << ::std::endl
+       << "By default \033[1mpkg-disfigure\033[0m will remove the package's build system configuration" << ::std::endl
+       << "(\033[1mconfig.build\033[0m) and also clean its output directory. This behavior can be" << ::std::endl
+       << "suppressed with the \033[1m--keep-config\033[0m and \033[1m--keep-out\033[0m options, respectively, for" << ::std::endl
+       << "example, if the package is to be reconfigured." << ::std::endl;
+
+    p = ::bpkg::pkg_disfigure_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-disfigure\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-disfigure.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-disfigure\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-disfigure-options.hxx b/bpkg/pkg-disfigure-options.hxx
new file mode 100644
index 0000000..2ee4a48
--- /dev/null
+++ b/bpkg/pkg-disfigure-options.hxx
@@ -0,0 +1,117 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_DISFIGURE_OPTIONS_HXX
+#define BPKG_PKG_DISFIGURE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_disfigure_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_disfigure_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_disfigure_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    keep_out () const;
+
+    const bool&
+    keep_config () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool keep_out_;
+    bool keep_config_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_disfigure_usage (::std::ostream&,
+                                  ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-disfigure-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_DISFIGURE_OPTIONS_HXX
diff --git a/bpkg/pkg-disfigure-options.ixx b/bpkg/pkg-disfigure-options.ixx
new file mode 100644
index 0000000..9868fda
--- /dev/null
+++ b/bpkg/pkg-disfigure-options.ixx
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_disfigure_options
+  //
+
+  inline const bool& pkg_disfigure_options::
+  keep_out () const
+  {
+    return this->keep_out_;
+  }
+
+  inline const bool& pkg_disfigure_options::
+  keep_config () const
+  {
+    return this->keep_config_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-drop-options.cxx b/bpkg/pkg-drop-options.cxx
new file mode 100644
index 0000000..c9956b2
--- /dev/null
+++ b/bpkg/pkg-drop-options.cxx
@@ -0,0 +1,845 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-drop-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_drop_options
+  //
+
+  pkg_drop_options::
+  pkg_drop_options ()
+  : all_ (),
+    all_pattern_ (),
+    all_pattern_specified_ (false),
+    yes_ (),
+    no_ (),
+    keep_unused_ (),
+    drop_dependent_ (),
+    keep_dependent_ (),
+    dependent_exit_ (),
+    dependent_exit_specified_ (false),
+    disfigure_only_ (),
+    print_only_ (),
+    plan_ (),
+    plan_specified_ (false)
+  {
+  }
+
+  bool pkg_drop_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_drop_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_drop_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_drop_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_drop_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_drop_options::
+  merge (const pkg_drop_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.all_pattern_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->all_pattern_, a.all_pattern_);
+      this->all_pattern_specified_ = true;
+    }
+
+    if (a.yes_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->yes_, a.yes_);
+    }
+
+    if (a.no_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_, a.no_);
+    }
+
+    if (a.keep_unused_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_unused_, a.keep_unused_);
+    }
+
+    if (a.drop_dependent_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->drop_dependent_, a.drop_dependent_);
+    }
+
+    if (a.keep_dependent_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_dependent_, a.keep_dependent_);
+    }
+
+    if (a.dependent_exit_specified_)
+    {
+      ::bpkg::cli::parser< uint16_t>::merge (
+        this->dependent_exit_, a.dependent_exit_);
+      this->dependent_exit_specified_ = true;
+    }
+
+    if (a.disfigure_only_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->disfigure_only_, a.disfigure_only_);
+    }
+
+    if (a.print_only_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->print_only_, a.print_only_);
+    }
+
+    if (a.plan_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->plan_, a.plan_);
+      this->plan_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_drop_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-DROP OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Drop all held packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all-pattern\033[0m \033[4mpattern\033[0m     Drop held packages that match the specified wildcard" << ::std::endl
+       << "                          pattern. Repeat this option to match multiple" << ::std::endl
+       << "                          patterns. Note that you may need to quote the pattern" << ::std::endl
+       << "                          to prevent expansion by your shell." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--yes\033[0m|\033[1m-y\033[0m                  Assume the answer to all prompts is \033[1myes\033[0m. Note that" << ::std::endl
+       << "                          this option does not apply to the dropping of" << ::std::endl
+       << "                          dependents; use \033[1m--drop-dependent\033[0m for that." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no\033[0m|\033[1m-n\033[0m                   Assume the answer to all prompts is \033[1mno\033[0m. Only makes" << ::std::endl
+       << "                          sense together with \033[1m--print-only|-p\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-unused\033[0m|\033[1m-K\033[0m          Don't drop dependency packages that were" << ::std::endl
+       << "                          automatically built but will no longer be used." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--drop-dependent\033[0m|\033[1m-D\033[0m       Don't warn about or ask for confirmation if dropping" << ::std::endl
+       << "                          dependent packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep-dependent\033[0m          Issue an error if attempting to drop dependent" << ::std::endl
+       << "                          packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--dependent-exit\033[0m \033[4mcode\033[0m     Silently exit with the specified error code if" << ::std::endl
+       << "                          attempting to drop dependent packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--disfigure-only\033[0m          Disfigure all the packages but don't purge." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--print-only\033[0m|\033[1m-p\033[0m           Print to \033[1mstdout\033[0m what would be done without actually" << ::std::endl
+       << "                          doing anything." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--plan\033[0m \033[4mheader\033[0m             Print the plan (even if \033[1m--yes\033[0m is specified) and start" << ::std::endl
+       << "                          it with the \033[4mheader\033[0m line (unless it is empty)." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_drop_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_drop_options_map;
+
+  static _cli_pkg_drop_options_map _cli_pkg_drop_options_map_;
+
+  struct _cli_pkg_drop_options_map_init
+  {
+    _cli_pkg_drop_options_map_init ()
+    {
+      _cli_pkg_drop_options_map_["--all"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::all_ >;
+      _cli_pkg_drop_options_map_["-a"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::all_ >;
+      _cli_pkg_drop_options_map_["--all-pattern"] =
+      &::bpkg::cli::thunk< pkg_drop_options, strings, &pkg_drop_options::all_pattern_,
+        &pkg_drop_options::all_pattern_specified_ >;
+      _cli_pkg_drop_options_map_["--yes"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::yes_ >;
+      _cli_pkg_drop_options_map_["-y"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::yes_ >;
+      _cli_pkg_drop_options_map_["--no"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::no_ >;
+      _cli_pkg_drop_options_map_["-n"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::no_ >;
+      _cli_pkg_drop_options_map_["--keep-unused"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::keep_unused_ >;
+      _cli_pkg_drop_options_map_["-K"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::keep_unused_ >;
+      _cli_pkg_drop_options_map_["--drop-dependent"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::drop_dependent_ >;
+      _cli_pkg_drop_options_map_["-D"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::drop_dependent_ >;
+      _cli_pkg_drop_options_map_["--keep-dependent"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::keep_dependent_ >;
+      _cli_pkg_drop_options_map_["--dependent-exit"] =
+      &::bpkg::cli::thunk< pkg_drop_options, uint16_t, &pkg_drop_options::dependent_exit_,
+        &pkg_drop_options::dependent_exit_specified_ >;
+      _cli_pkg_drop_options_map_["--disfigure-only"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::disfigure_only_ >;
+      _cli_pkg_drop_options_map_["--print-only"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::print_only_ >;
+      _cli_pkg_drop_options_map_["-p"] =
+      &::bpkg::cli::thunk< pkg_drop_options, &pkg_drop_options::print_only_ >;
+      _cli_pkg_drop_options_map_["--plan"] =
+      &::bpkg::cli::thunk< pkg_drop_options, string, &pkg_drop_options::plan_,
+        &pkg_drop_options::plan_specified_ >;
+    }
+  };
+
+  static _cli_pkg_drop_options_map_init _cli_pkg_drop_options_map_init_;
+
+  bool pkg_drop_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_drop_options_map::const_iterator i (_cli_pkg_drop_options_map_.find (o));
+
+    if (i != _cli_pkg_drop_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_drop_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_drop_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-drop\033[0m|\033[1mdrop\033[0m [\033[4moptions\033[0m] <pkg>..." << ::std::endl
+       << "\033[1mbpkg pkg-drop\033[0m|\033[1mdrop\033[0m [\033[4moptions\033[0m] \033[1m--all\033[0m|\033[1m-a\033[0m" << ::std::endl
+       << "\033[1mbpkg pkg-drop\033[0m|\033[1mdrop\033[0m [\033[4moptions\033[0m] (\033[1m--all-pattern\033[0m <pattern>)...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-drop\033[0m command drops from the configuration the specified packages (the" << ::std::endl
+       << "first form), all the held packages (the second form, see \033[1mbpkg-pkg-status(1)\033[0m)," << ::std::endl
+       << "or all the held packages that match any of the specified wildcard patterns (the" << ::std::endl
+       << "third form). If the packages being dropped still have dependent packages, then" << ::std::endl
+       << "those will have to be dropped as well and you will be prompted to confirm. And" << ::std::endl
+       << "if the packages being dropped have dependency packages that would otherwise no" << ::std::endl
+       << "longer be used, then they will be dropped as well unless the \033[1m--keep-unused\033[0m|\033[1m-K\033[0m\033[0m" << ::std::endl
+       << "option is specified." << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-drop\033[0m command also supports several options (described below) that allow" << ::std::endl
+       << "you to control the amount of work that will be done." << ::std::endl;
+
+    p = ::bpkg::pkg_drop_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-drop\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-drop.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-drop\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-drop-options.hxx b/bpkg/pkg-drop-options.hxx
new file mode 100644
index 0000000..e72e9fb
--- /dev/null
+++ b/bpkg/pkg-drop-options.hxx
@@ -0,0 +1,165 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_DROP_OPTIONS_HXX
+#define BPKG_PKG_DROP_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_drop_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_drop_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_drop_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const strings&
+    all_pattern () const;
+
+    bool
+    all_pattern_specified () const;
+
+    const bool&
+    yes () const;
+
+    const bool&
+    no () const;
+
+    const bool&
+    keep_unused () const;
+
+    const bool&
+    drop_dependent () const;
+
+    const bool&
+    keep_dependent () const;
+
+    const uint16_t&
+    dependent_exit () const;
+
+    bool
+    dependent_exit_specified () const;
+
+    const bool&
+    disfigure_only () const;
+
+    const bool&
+    print_only () const;
+
+    const string&
+    plan () const;
+
+    bool
+    plan_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    strings all_pattern_;
+    bool all_pattern_specified_;
+    bool yes_;
+    bool no_;
+    bool keep_unused_;
+    bool drop_dependent_;
+    bool keep_dependent_;
+    uint16_t dependent_exit_;
+    bool dependent_exit_specified_;
+    bool disfigure_only_;
+    bool print_only_;
+    string plan_;
+    bool plan_specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_drop_usage (::std::ostream&,
+                             ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-drop-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_DROP_OPTIONS_HXX
diff --git a/bpkg/pkg-drop-options.ixx b/bpkg/pkg-drop-options.ixx
new file mode 100644
index 0000000..b32cb95
--- /dev/null
+++ b/bpkg/pkg-drop-options.ixx
@@ -0,0 +1,105 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_drop_options
+  //
+
+  inline const bool& pkg_drop_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const strings& pkg_drop_options::
+  all_pattern () const
+  {
+    return this->all_pattern_;
+  }
+
+  inline bool pkg_drop_options::
+  all_pattern_specified () const
+  {
+    return this->all_pattern_specified_;
+  }
+
+  inline const bool& pkg_drop_options::
+  yes () const
+  {
+    return this->yes_;
+  }
+
+  inline const bool& pkg_drop_options::
+  no () const
+  {
+    return this->no_;
+  }
+
+  inline const bool& pkg_drop_options::
+  keep_unused () const
+  {
+    return this->keep_unused_;
+  }
+
+  inline const bool& pkg_drop_options::
+  drop_dependent () const
+  {
+    return this->drop_dependent_;
+  }
+
+  inline const bool& pkg_drop_options::
+  keep_dependent () const
+  {
+    return this->keep_dependent_;
+  }
+
+  inline const uint16_t& pkg_drop_options::
+  dependent_exit () const
+  {
+    return this->dependent_exit_;
+  }
+
+  inline bool pkg_drop_options::
+  dependent_exit_specified () const
+  {
+    return this->dependent_exit_specified_;
+  }
+
+  inline const bool& pkg_drop_options::
+  disfigure_only () const
+  {
+    return this->disfigure_only_;
+  }
+
+  inline const bool& pkg_drop_options::
+  print_only () const
+  {
+    return this->print_only_;
+  }
+
+  inline const string& pkg_drop_options::
+  plan () const
+  {
+    return this->plan_;
+  }
+
+  inline bool pkg_drop_options::
+  plan_specified () const
+  {
+    return this->plan_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-fetch-options.cxx b/bpkg/pkg-fetch-options.cxx
new file mode 100644
index 0000000..ae911d2
--- /dev/null
+++ b/bpkg/pkg-fetch-options.cxx
@@ -0,0 +1,727 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-fetch-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_fetch_options
+  //
+
+  pkg_fetch_options::
+  pkg_fetch_options ()
+  : replace_ (),
+    existing_ (),
+    purge_ ()
+  {
+  }
+
+  bool pkg_fetch_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_fetch_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_fetch_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_fetch_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_fetch_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_fetch_options::
+  merge (const pkg_fetch_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.replace_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->replace_, a.replace_);
+    }
+
+    if (a.existing_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->existing_, a.existing_);
+    }
+
+    if (a.purge_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->purge_, a.purge_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_fetch_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-FETCH OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--replace\033[0m|\033[1m-r\033[0m              Replace the archive if the package is already fetched" << ::std::endl
+       << "                          or unpacked." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--existing\033[0m|\033[1m-e\033[0m             Treat the argument as an existing package archive" << ::std::endl
+       << "                          path rather than the package name/version to fetch." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--purge\033[0m|\033[1m-p\033[0m                Remove the existing package archive when the package" << ::std::endl
+       << "                          is purged." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_fetch_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_fetch_options_map;
+
+  static _cli_pkg_fetch_options_map _cli_pkg_fetch_options_map_;
+
+  struct _cli_pkg_fetch_options_map_init
+  {
+    _cli_pkg_fetch_options_map_init ()
+    {
+      _cli_pkg_fetch_options_map_["--replace"] =
+      &::bpkg::cli::thunk< pkg_fetch_options, &pkg_fetch_options::replace_ >;
+      _cli_pkg_fetch_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_fetch_options, &pkg_fetch_options::replace_ >;
+      _cli_pkg_fetch_options_map_["--existing"] =
+      &::bpkg::cli::thunk< pkg_fetch_options, &pkg_fetch_options::existing_ >;
+      _cli_pkg_fetch_options_map_["-e"] =
+      &::bpkg::cli::thunk< pkg_fetch_options, &pkg_fetch_options::existing_ >;
+      _cli_pkg_fetch_options_map_["--purge"] =
+      &::bpkg::cli::thunk< pkg_fetch_options, &pkg_fetch_options::purge_ >;
+      _cli_pkg_fetch_options_map_["-p"] =
+      &::bpkg::cli::thunk< pkg_fetch_options, &pkg_fetch_options::purge_ >;
+    }
+  };
+
+  static _cli_pkg_fetch_options_map_init _cli_pkg_fetch_options_map_init_;
+
+  bool pkg_fetch_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_fetch_options_map::const_iterator i (_cli_pkg_fetch_options_map_.find (o));
+
+    if (i != _cli_pkg_fetch_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_fetch_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_fetch_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-fetch\033[0m [\033[4moptions\033[0m] (\033[4mpkg\033[0m\033[1m/\033[0m\033[4mver\033[0m | \033[1m--existing|-e\033[0m \033[4mfile\033[0m)\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-fetch\033[0m command fetches the archive for the specified package name and" << ::std::endl
+       << "version from one of the archive-based repositories (\033[1mbpkg-rep-add(1)\033[0m). The" << ::std::endl
+       << "resulting package state is \033[1mfetched\033[0m (\033[1mbpkg-pkg-status(1)\033[0m)." << ::std::endl
+       << ::std::endl
+       << "If the \033[1m--replace|-r\033[0m option is specified, then \033[1mpkg-fetch\033[0m will replace the" << ::std::endl
+       << "archive of a package that is already in the \033[1mfetched\033[0m or \033[1munpacked\033[0m state." << ::std::endl
+       << "Otherwise, \033[1mpkg-fetch\033[0m expects the package to not exist in the configuration." << ::std::endl
+       << ::std::endl
+       << "If the \033[1m--existing|-e\033[0m option is used, then instead of the name and version" << ::std::endl
+       << "arguments, \033[1mpkg-fetch\033[0m expects a local path to an existing package archive. In" << ::std::endl
+       << "this case, \033[1mbpkg\033[0m will use the archive in place, without copying it into the" << ::std::endl
+       << "configuration directory. Also, unless the \033[1m--purge|-p\033[0m option is specified, \033[1mbpkg\033[0m" << ::std::endl
+       << "will not attempt to remove this archive when the package is later purged with" << ::std::endl
+       << "the \033[1mbpkg-pkg-purge(1)\033[0m command." << ::std::endl;
+
+    p = ::bpkg::pkg_fetch_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-fetch\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-fetch.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-fetch\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl
+       << "--purge|-p" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-fetch-options.hxx b/bpkg/pkg-fetch-options.hxx
new file mode 100644
index 0000000..99c834c
--- /dev/null
+++ b/bpkg/pkg-fetch-options.hxx
@@ -0,0 +1,121 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_FETCH_OPTIONS_HXX
+#define BPKG_PKG_FETCH_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_fetch_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_fetch_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_fetch_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    replace () const;
+
+    const bool&
+    existing () const;
+
+    const bool&
+    purge () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool replace_;
+    bool existing_;
+    bool purge_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_fetch_usage (::std::ostream&,
+                              ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-fetch-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_FETCH_OPTIONS_HXX
diff --git a/bpkg/pkg-fetch-options.ixx b/bpkg/pkg-fetch-options.ixx
new file mode 100644
index 0000000..e57a26f
--- /dev/null
+++ b/bpkg/pkg-fetch-options.ixx
@@ -0,0 +1,39 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_fetch_options
+  //
+
+  inline const bool& pkg_fetch_options::
+  replace () const
+  {
+    return this->replace_;
+  }
+
+  inline const bool& pkg_fetch_options::
+  existing () const
+  {
+    return this->existing_;
+  }
+
+  inline const bool& pkg_fetch_options::
+  purge () const
+  {
+    return this->purge_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-install-options.cxx b/bpkg/pkg-install-options.cxx
new file mode 100644
index 0000000..dcd0147
--- /dev/null
+++ b/bpkg/pkg-install-options.cxx
@@ -0,0 +1,750 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-install-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_install_options
+  //
+
+  pkg_install_options::
+  pkg_install_options ()
+  : all_ (),
+    all_pattern_ (),
+    all_pattern_specified_ (false),
+    immediate_ (),
+    recursive_ ()
+  {
+  }
+
+  bool pkg_install_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_install_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_install_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_install_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_install_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_install_options::
+  merge (const pkg_install_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.all_pattern_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->all_pattern_, a.all_pattern_);
+      this->all_pattern_specified_ = true;
+    }
+
+    if (a.immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->immediate_, a.immediate_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_install_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-INSTALL OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Install all held packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all-pattern\033[0m \033[4mpattern\033[0m     Install held packages that match the specified" << ::std::endl
+       << "                          wildcard pattern. Repeat this option to match" << ::std::endl
+       << "                          multiple patterns. Note that you may need to quote" << ::std::endl
+       << "                          the pattern to prevent expansion by your shell." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--immediate\033[0m|\033[1m-i\033[0m            Also install immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m|\033[1m-r\033[0m            Also install all dependencies, recursively." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_install_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_install_options_map;
+
+  static _cli_pkg_install_options_map _cli_pkg_install_options_map_;
+
+  struct _cli_pkg_install_options_map_init
+  {
+    _cli_pkg_install_options_map_init ()
+    {
+      _cli_pkg_install_options_map_["--all"] =
+      &::bpkg::cli::thunk< pkg_install_options, &pkg_install_options::all_ >;
+      _cli_pkg_install_options_map_["-a"] =
+      &::bpkg::cli::thunk< pkg_install_options, &pkg_install_options::all_ >;
+      _cli_pkg_install_options_map_["--all-pattern"] =
+      &::bpkg::cli::thunk< pkg_install_options, strings, &pkg_install_options::all_pattern_,
+        &pkg_install_options::all_pattern_specified_ >;
+      _cli_pkg_install_options_map_["--immediate"] =
+      &::bpkg::cli::thunk< pkg_install_options, &pkg_install_options::immediate_ >;
+      _cli_pkg_install_options_map_["-i"] =
+      &::bpkg::cli::thunk< pkg_install_options, &pkg_install_options::immediate_ >;
+      _cli_pkg_install_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_install_options, &pkg_install_options::recursive_ >;
+      _cli_pkg_install_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_install_options, &pkg_install_options::recursive_ >;
+    }
+  };
+
+  static _cli_pkg_install_options_map_init _cli_pkg_install_options_map_init_;
+
+  bool pkg_install_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_install_options_map::const_iterator i (_cli_pkg_install_options_map_.find (o));
+
+    if (i != _cli_pkg_install_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_install_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_install_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-install\033[0m|\033[1minstall\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[4mpkg\033[0m..." << ::std::endl
+       << "\033[1mbpkg pkg-install\033[0m|\033[1minstall\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[1m--all\033[0m|\033[1m-a\033[0m" << ::std::endl
+       << "\033[1mbpkg pkg-install\033[0m|\033[1minstall\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] (\033[1m--all-pattern\033[0m <pattern>)...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-install\033[0m command installs the specified packages (the first form), all" << ::std::endl
+       << "the held packages (the second form, see \033[1mbpkg-pkg-status(1)\033[0m), or all the held" << ::std::endl
+       << "packages that match any of the specified wildcard patterns (the third form)." << ::std::endl
+       << "Additionally, immediate or all dependencies of these packages can be also" << ::std::endl
+       << "installed by specifying the \033[1m--immediate\033[0m|\033[1m-i\033[0m\033[0m or \033[1m--recursive\033[0m|\033[1m-r\033[0m\033[0m options," << ::std::endl
+       << "respectively. Underneath, this command doesn't do much more than run \033[1mb install\033[0m." << ::std::endl
+       << "In the first form the specified packages must have been previously configured" << ::std::endl
+       << "with \033[1mbpkg-pkg-build(1)\033[0m or \033[1mbpkg-pkg-configure(1)\033[0m." << ::std::endl
+       << ::std::endl
+       << "Additional command line variables (\033[4mvars\033[0m, normally \033[1mconfig.*\033[0m) can be passed to" << ::std::endl
+       << "the build system. Such variables apply to all the specified packages but can" << ::std::endl
+       << "also be specified to only apply to specific packages using the argument" << ::std::endl
+       << "grouping mechanism (see \033[1mbpkg-argument-grouping(1)\033[0m for details). In particular," << ::std::endl
+       << "this mechanism can be used to specify the installation directory, for example:" << ::std::endl
+       << ::std::endl
+       << "bpkg install config.install.root=/usr/local \\" << ::std::endl
+       << "             config.install.sudo=sudo       \\" << ::std::endl
+       << "             libfoo libbar" << ::std::endl
+       << ::std::endl
+       << "Alternatively, the installation directory can be specified once when creating" << ::std::endl
+       << "the configuration (\033[1mbpkg-cfg-create(1)\033[0m)." << ::std::endl;
+
+    p = ::bpkg::pkg_install_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-install\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-install.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-install\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-install-options.hxx b/bpkg/pkg-install-options.hxx
new file mode 100644
index 0000000..6beff63
--- /dev/null
+++ b/bpkg/pkg-install-options.hxx
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_INSTALL_OPTIONS_HXX
+#define BPKG_PKG_INSTALL_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_install_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_install_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_install_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const strings&
+    all_pattern () const;
+
+    bool
+    all_pattern_specified () const;
+
+    const bool&
+    immediate () const;
+
+    const bool&
+    recursive () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    strings all_pattern_;
+    bool all_pattern_specified_;
+    bool immediate_;
+    bool recursive_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_install_usage (::std::ostream&,
+                                ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-install-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_INSTALL_OPTIONS_HXX
diff --git a/bpkg/pkg-install-options.ixx b/bpkg/pkg-install-options.ixx
new file mode 100644
index 0000000..575b4b4
--- /dev/null
+++ b/bpkg/pkg-install-options.ixx
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_install_options
+  //
+
+  inline const bool& pkg_install_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const strings& pkg_install_options::
+  all_pattern () const
+  {
+    return this->all_pattern_;
+  }
+
+  inline bool pkg_install_options::
+  all_pattern_specified () const
+  {
+    return this->all_pattern_specified_;
+  }
+
+  inline const bool& pkg_install_options::
+  immediate () const
+  {
+    return this->immediate_;
+  }
+
+  inline const bool& pkg_install_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-purge-options.cxx b/bpkg/pkg-purge-options.cxx
new file mode 100644
index 0000000..65b59a4
--- /dev/null
+++ b/bpkg/pkg-purge-options.cxx
@@ -0,0 +1,707 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-purge-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_purge_options
+  //
+
+  pkg_purge_options::
+  pkg_purge_options ()
+  : keep_ (),
+    force_ ()
+  {
+  }
+
+  bool pkg_purge_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_purge_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_purge_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_purge_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_purge_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_purge_options::
+  merge (const pkg_purge_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.keep_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->keep_, a.keep_);
+    }
+
+    if (a.force_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->force_, a.force_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_purge_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-PURGE OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--keep\033[0m|\033[1m-k\033[0m                 Keep the package archive. Note that in this mode the" << ::std::endl
+       << "                          package is still retained in the configuration's" << ::std::endl
+       << "                          database in the \033[1mfetched\033[0m state." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--force\033[0m|\033[1m-f\033[0m                Purge a broken package. In this mode \033[1mbpkg\033[0m will verify" << ::std::endl
+       << "                          that the package directory and archive no longer" << ::std::endl
+       << "                          exist and then remove the package from the" << ::std::endl
+       << "                          configuration." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_purge_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_purge_options_map;
+
+  static _cli_pkg_purge_options_map _cli_pkg_purge_options_map_;
+
+  struct _cli_pkg_purge_options_map_init
+  {
+    _cli_pkg_purge_options_map_init ()
+    {
+      _cli_pkg_purge_options_map_["--keep"] =
+      &::bpkg::cli::thunk< pkg_purge_options, &pkg_purge_options::keep_ >;
+      _cli_pkg_purge_options_map_["-k"] =
+      &::bpkg::cli::thunk< pkg_purge_options, &pkg_purge_options::keep_ >;
+      _cli_pkg_purge_options_map_["--force"] =
+      &::bpkg::cli::thunk< pkg_purge_options, &pkg_purge_options::force_ >;
+      _cli_pkg_purge_options_map_["-f"] =
+      &::bpkg::cli::thunk< pkg_purge_options, &pkg_purge_options::force_ >;
+    }
+  };
+
+  static _cli_pkg_purge_options_map_init _cli_pkg_purge_options_map_init_;
+
+  bool pkg_purge_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_purge_options_map::const_iterator i (_cli_pkg_purge_options_map_.find (o));
+
+    if (i != _cli_pkg_purge_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_purge_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_purge_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-purge\033[0m [\033[4moptions\033[0m] \033[4mpkg\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-purge\033[0m command removes the package directory and archive from the" << ::std::endl
+       << "filesystem and removes the package from the configuration.  Only packages in" << ::std::endl
+       << "the \033[1mfetched\033[0m and \033[1munpacked\033[0m state (\033[1mbpkg-pkg-status(1)\033[0m) can be purged plus \033[1mbroken\033[0m" << ::std::endl
+       << "packages if the \033[1m--force|-f\033[0m option is specified (see the option's description" << ::std::endl
+       << "for details on purging broken packages). If the \033[1m--keep|-k\033[0m option is specified," << ::std::endl
+       << "then the package archive is not removed (see the option's description for" << ::std::endl
+       << "details on this mode)." << ::std::endl;
+
+    p = ::bpkg::pkg_purge_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-purge\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-purge.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-purge\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-purge-options.hxx b/bpkg/pkg-purge-options.hxx
new file mode 100644
index 0000000..2649a4a
--- /dev/null
+++ b/bpkg/pkg-purge-options.hxx
@@ -0,0 +1,117 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_PURGE_OPTIONS_HXX
+#define BPKG_PKG_PURGE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_purge_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_purge_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_purge_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    keep () const;
+
+    const bool&
+    force () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool keep_;
+    bool force_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_purge_usage (::std::ostream&,
+                              ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-purge-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_PURGE_OPTIONS_HXX
diff --git a/bpkg/pkg-purge-options.ixx b/bpkg/pkg-purge-options.ixx
new file mode 100644
index 0000000..85b3e75
--- /dev/null
+++ b/bpkg/pkg-purge-options.ixx
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_purge_options
+  //
+
+  inline const bool& pkg_purge_options::
+  keep () const
+  {
+    return this->keep_;
+  }
+
+  inline const bool& pkg_purge_options::
+  force () const
+  {
+    return this->force_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-status-options.cxx b/bpkg/pkg-status-options.cxx
new file mode 100644
index 0000000..46ca79e
--- /dev/null
+++ b/bpkg/pkg-status-options.cxx
@@ -0,0 +1,973 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-status-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_status_options
+  //
+
+  pkg_status_options::
+  pkg_status_options ()
+  : all_ (),
+    link_ (),
+    immediate_ (),
+    recursive_ (),
+    old_available_ (),
+    constraint_ (),
+    system_ (),
+    no_hold_ (),
+    no_hold_package_ (),
+    no_hold_version_ ()
+  {
+  }
+
+  bool pkg_status_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_status_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_status_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_status_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_status_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_status_options::
+  merge (const pkg_status_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.link_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->link_, a.link_);
+    }
+
+    if (a.immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->immediate_, a.immediate_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+
+    if (a.old_available_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->old_available_, a.old_available_);
+    }
+
+    if (a.constraint_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->constraint_, a.constraint_);
+    }
+
+    if (a.system_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->system_, a.system_);
+    }
+
+    if (a.no_hold_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_hold_, a.no_hold_);
+    }
+
+    if (a.no_hold_package_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_hold_package_, a.no_hold_package_);
+    }
+
+    if (a.no_hold_version_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->no_hold_version_, a.no_hold_version_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_status_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-STATUS OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Print the status of all the packages, not just held." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--link\033[0m                    Also print the status of held/all packages from" << ::std::endl
+       << "                          linked configurations." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--immediate\033[0m|\033[1m-i\033[0m            Also print the status of immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m|\033[1m-r\033[0m            Also print the status of all dependencies," << ::std::endl
+       << "                          recursively." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--old-available\033[0m|\033[1m-o\033[0m        Print old available versions." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--constraint\033[0m              Print version constraints for dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--system\033[0m                  Check the availability of packages from the system." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-hold\033[0m                 Don't print the package or version hold status." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-hold-package\033[0m         Don't print the package hold status." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--no-hold-version\033[0m         Don't print the version hold status." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_status_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_status_options_map;
+
+  static _cli_pkg_status_options_map _cli_pkg_status_options_map_;
+
+  struct _cli_pkg_status_options_map_init
+  {
+    _cli_pkg_status_options_map_init ()
+    {
+      _cli_pkg_status_options_map_["--all"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::all_ >;
+      _cli_pkg_status_options_map_["-a"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::all_ >;
+      _cli_pkg_status_options_map_["--link"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::link_ >;
+      _cli_pkg_status_options_map_["--immediate"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::immediate_ >;
+      _cli_pkg_status_options_map_["-i"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::immediate_ >;
+      _cli_pkg_status_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::recursive_ >;
+      _cli_pkg_status_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::recursive_ >;
+      _cli_pkg_status_options_map_["--old-available"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::old_available_ >;
+      _cli_pkg_status_options_map_["-o"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::old_available_ >;
+      _cli_pkg_status_options_map_["--constraint"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::constraint_ >;
+      _cli_pkg_status_options_map_["--system"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::system_ >;
+      _cli_pkg_status_options_map_["--no-hold"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::no_hold_ >;
+      _cli_pkg_status_options_map_["--no-hold-package"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::no_hold_package_ >;
+      _cli_pkg_status_options_map_["--no-hold-version"] =
+      &::bpkg::cli::thunk< pkg_status_options, &pkg_status_options::no_hold_version_ >;
+    }
+  };
+
+  static _cli_pkg_status_options_map_init _cli_pkg_status_options_map_init_;
+
+  bool pkg_status_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_status_options_map::const_iterator i (_cli_pkg_status_options_map_.find (o));
+
+    if (i != _cli_pkg_status_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_status_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_status_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-status\033[0m|\033[1mstatus\033[0m [\033[4moptions\033[0m] [\033[4mpkg\033[0m[\033[1m/\033[0m\033[4mver\033[0m]...]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-status\033[0m command prints the status of the specified packages or, if \033[4mver\033[0m" << ::std::endl
+       << "is specified, package versions. If no packages were specified, then \033[1mpkg-status\033[0m" << ::std::endl
+       << "prints the status of all the held packages (which are the packages that were" << ::std::endl
+       << "explicitly built; see \033[1mbpkg-pkg-build(1)\033[0m). The latter mode can be modified to" << ::std::endl
+       << "print the status of all the packages by specifying the \033[1m--all\033[0m|\033[1m-a\033[0m\033[0m option." << ::std::endl
+       << "Additionally, the status of immediate or all dependencies of the above packages" << ::std::endl
+       << "can be printed by specifying the \033[1m--immediate\033[0m|\033[1m-i\033[0m\033[0m or \033[1m--recursive\033[0m|\033[1m-r\033[0m\033[0m options," << ::std::endl
+       << "respectively. Note that the status is written to \033[1mstdout\033[0m, not \033[1mstderr\033[0m." << ::std::endl
+       << ::std::endl
+       << "The default output format (see the \033[1m--stdout-format\033[0m common option) is regular" << ::std::endl
+       << "with components separated with spaces. Each line starts with the package name" << ::std::endl
+       << "followed by one of the status words listed below. Some of them can be" << ::std::endl
+       << "optionally followed by '\033[1m,\033[0m' (no spaces) and a sub-status word. Lines" << ::std::endl
+       << "corresponding to dependencies from linked configurations will additionally" << ::std::endl
+       << "mention the configuration directory in square brackets after the package name." << ::std::endl
+       << ::std::endl
+       << "\033[1munknown\033[0m" << ::std::endl
+       << "    Package is not part of the configuration nor available from any of the" << ::std::endl
+       << "    repositories." << ::std::endl
+       << "\033[1mavailable\033[0m" << ::std::endl
+       << "    Package is not part of the configuration but is available from one of the" << ::std::endl
+       << "    repositories." << ::std::endl
+       << "\033[1mfetched\033[0m" << ::std::endl
+       << "    Package is part of the configuration and is fetched." << ::std::endl
+       << "\033[1munpacked\033[0m" << ::std::endl
+       << "    Package is part of the configuration and is unpacked." << ::std::endl
+       << "\033[1mconfigured\033[0m" << ::std::endl
+       << "    Package is part of the configuration and is configured. May be followed by" << ::std::endl
+       << "    the \033[1msystem\033[0m sub-status indicating a package coming from the system. The" << ::std::endl
+       << "    version of such a system package (described below) may be the special '\033[1m*\033[0m'" << ::std::endl
+       << "    value indicating a wildcard version." << ::std::endl
+       << "\033[1mbroken\033[0m" << ::std::endl
+       << "    Package is part of the configuration and is broken (broken packages can" << ::std::endl
+       << "    only be purged; see \033[1mbpkg-pkg-purge(1)\033[0m)." << ::std::endl
+       << ::std::endl
+       << "If only the package name was specified without the package version, then the" << ::std::endl
+       << "\033[1mavailable\033[0m status word is followed by the list of available versions. Versions" << ::std::endl
+       << "that are only available for up/down-grading are printed in '\033[1m[]\033[0m' (such version" << ::std::endl
+       << "are only available as dependencies from prerequisite repositories of other" << ::std::endl
+       << "repositories). If the \033[1m--system\033[0m option is specified, then the last version in" << ::std::endl
+       << "this list may have the \033[1msys:\033[0m prefix indicating an available system version. Such" << ::std::endl
+       << "a system version may be the special '\033[1m?\033[0m' value indicating that a package may or" << ::std::endl
+       << "may not be available from the system and that its version is unknown." << ::std::endl
+       << ::std::endl
+       << "The \033[1mfetched\033[0m, \033[1munpacked\033[0m, \033[1mconfigured\033[0m, and \033[1mbroken\033[0m status words are followed by the" << ::std::endl
+       << "version of the package. If the package version was specified, then the \033[1munknown\033[0m" << ::std::endl
+       << "status word is also followed by the version." << ::std::endl
+       << ::std::endl
+       << "If the status is \033[1mfetched\033[0m, \033[1munpacked\033[0m, \033[1mconfigured\033[0m, or \033[1mbroken\033[0m and newer versions" << ::std::endl
+       << "are available, then the package version is followed by the \033[1mavailable\033[0m status" << ::std::endl
+       << "word and the list of newer versions. To instead see a list of all versions," << ::std::endl
+       << "including the older ones, specify the \033[1m--old-available\033[0m|\033[1m-o\033[0m\033[0m option. In this case" << ::std::endl
+       << "the currently selected version is printed in '\033[1m()\033[0m'." << ::std::endl
+       << ::std::endl
+       << "If the package name was specified with the version, then only the status (such" << ::std::endl
+       << "as, \033[1mconfigured\033[0m, \033[1mavailable\033[0m, etc.) of this version is considered." << ::std::endl
+       << ::std::endl
+       << "If a package is being held, then its name is printed prefixed with '\033[1m!\033[0m'." << ::std::endl
+       << "Similarly, if a package version is being held, then the version is printed" << ::std::endl
+       << "prefixed with '\033[1m!\033[0m'. Held packages and held versions were selected by the user" << ::std::endl
+       << "and are not automatically dropped and upgraded, respectively." << ::std::endl
+       << ::std::endl
+       << "Below are some examples, assuming the configuration has \033[1mlibfoo\033[0m \033[1m1.0.0\033[0m configured" << ::std::endl
+       << "and held (both package and version) as well as \033[1mlibfoo\033[0m \033[1m1.1.0\033[0m and \033[1m1.1.1\033[0m available" << ::std::endl
+       << "from source and \033[1m1.1.0\033[0m from the system." << ::std::endl
+       << ::std::endl
+       << "bpkg status libbar" << ::std::endl
+       << "libbar unknown" << ::std::endl
+       << ::std::endl
+       << "bpkg status libbar/1.0.0" << ::std::endl
+       << "libbar unknown 1.0.0" << ::std::endl
+       << ::std::endl
+       << "bpkg status libfoo/1.0.0" << ::std::endl
+       << "!libfoo configured !1.0.0" << ::std::endl
+       << ::std::endl
+       << "bpkg status libfoo/1.1.0" << ::std::endl
+       << "libfoo available 1.1.0" << ::std::endl
+       << ::std::endl
+       << "bpkg status --system libfoo/1.1.0" << ::std::endl
+       << "libfoo available 1.1.0 sys:1.1.0" << ::std::endl
+       << ::std::endl
+       << "bpkg status libfoo" << ::std::endl
+       << "!libfoo configured !1.0.0 available 1.1.0 1.1.1" << ::std::endl
+       << ::std::endl
+       << "bpkg status libfoo/1.1.1 libbar" << ::std::endl
+       << "libfoo available 1.1.1" << ::std::endl
+       << "libbar unknown" << ::std::endl
+       << ::std::endl
+       << "Assuming now that we dropped \033[1mlibfoo\033[0m from the configuration:" << ::std::endl
+       << ::std::endl
+       << "bpkg status libfoo/1.0.0" << ::std::endl
+       << "libfoo unknown 1.0.0" << ::std::endl
+       << ::std::endl
+       << "bpkg status libfoo" << ::std::endl
+       << "libfoo available 1.1.0 1.1.1" << ::std::endl
+       << ::std::endl
+       << "And assuming now that we built \033[1mlibfoo\033[0m as a system package with the wildcard" << ::std::endl
+       << "version:" << ::std::endl
+       << ::std::endl
+       << "bpkg status libfoo" << ::std::endl
+       << "!libfoo configured,system !* available 1.1.0 1.1.1" << ::std::endl
+       << ::std::endl
+       << "Another example of the status output this time including dependencies:" << ::std::endl
+       << ::std::endl
+       << "bpkg status -r libbaz" << ::std::endl
+       << "!libbaz configured 1.0.0" << ::std::endl
+       << "  libfoo configured 1.0.0" << ::std::endl
+       << "    bison [.bpkg/host/] configured 1.0.0" << ::std::endl
+       << "  libbar configured 2.0.0" << ::std::endl
+       << ::std::endl
+       << "If the output format is \033[1mjson\033[0m, then the output is a JSON array of objects which" << ::std::endl
+       << "are the serialized representation of the following C++ \033[1mstruct\033[0m \033[1mpackage_status\033[0m:" << ::std::endl
+       << ::std::endl
+       << "struct available_version" << ::std::endl
+       << "{" << ::std::endl
+       << "  string version;" << ::std::endl
+       << "  bool   system;" << ::std::endl
+       << "  bool   dependency;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "struct package_status" << ::std::endl
+       << "{" << ::std::endl
+       << "  string                    name;" << ::std::endl
+       << "  optional<string>          configuration;" << ::std::endl
+       << "  optional<string>          constraint;" << ::std::endl
+       << "  string                    status;" << ::std::endl
+       << "  optional<string>          sub_status;" << ::std::endl
+       << "  optional<string>          version;" << ::std::endl
+       << "  bool                      hold_package;" << ::std::endl
+       << "  bool                      hold_version;" << ::std::endl
+       << "  vector<available_version> available_versions;" << ::std::endl
+       << "  vector<package_status>    dependencies;" << ::std::endl
+       << "};" << ::std::endl
+       << ::std::endl
+       << "For example:" << ::std::endl
+       << ::std::endl
+       << "[" << ::std::endl
+       << "  {" << ::std::endl
+       << "    \"name\": \"hello\"," << ::std::endl
+       << "    \"status\": \"configured\"," << ::std::endl
+       << "    \"version\": \"1.0.0\"," << ::std::endl
+       << "    \"hold_package\": true," << ::std::endl
+       << "    \"available_versions\": [" << ::std::endl
+       << "      {" << ::std::endl
+       << "        \"version\": \"1.0.1\"" << ::std::endl
+       << "      }," << ::std::endl
+       << "      {" << ::std::endl
+       << "        \"version\": \"2.0.0\"" << ::std::endl
+       << "      }" << ::std::endl
+       << "    ]," << ::std::endl
+       << "    \"dependencies\": [" << ::std::endl
+       << "      {" << ::std::endl
+       << "        \"name\": \"libhello\"," << ::std::endl
+       << "        \"status\": \"configured\"," << ::std::endl
+       << "        \"version\": \"1.0.2\"," << ::std::endl
+       << "      }" << ::std::endl
+       << "    ]" << ::std::endl
+       << "  }" << ::std::endl
+       << "]" << ::std::endl
+       << ::std::endl
+       << "See the JSON OUTPUT section in \033[1mbpkg-common-options(1)\033[0m for details on the" << ::std::endl
+       << "overall properties of this format and the semantics of the \033[1mstruct\033[0m" << ::std::endl
+       << "serialization." << ::std::endl
+       << ::std::endl
+       << "In \033[1mpackage_status\033[0m, the \033[1mconfiguration\033[0m member contains the absolute directory of" << ::std::endl
+       << "a linked configuration if this package resides in a linked configuration. The" << ::std::endl
+       << "\033[1mconstraint\033[0m member is present only if the \033[1m--constraint\033[0m option is specified. The" << ::std::endl
+       << "\033[1mversion\033[0m member is absent if the \033[1mstatus\033[0m member is \033[1munknown\033[0m or \033[1mavailable\033[0m and no" << ::std::endl
+       << "package version is specified on the command line. If the \033[1msub_status\033[0m member is" << ::std::endl
+       << "\033[1msystem\033[0m, then the \033[1mversion\033[0m member can be special \033[1m*\033[0m. The \033[1mdependencies\033[0m member is" << ::std::endl
+       << "present only if the \033[1m--immediate|-i\033[0m or \033[1m--recursive|-r\033[0m options are specified." << ::std::endl
+       << ::std::endl
+       << "In \033[1mavailable_version\033[0m, if the \033[1msystem\033[0m member is \033[1mtrue\033[0m, then this version is" << ::std::endl
+       << "available from the system, in which case the \033[1mversion\033[0m member can be special \033[1m?\033[0m or" << ::std::endl
+       << "\033[1m*\033[0m. If the \033[1mdependency\033[0m member is \033[1mtrue\033[0m, then this version is only available as a" << ::std::endl
+       << "dependency from prerequisite repositories of other repositories." << ::std::endl;
+
+    p = ::bpkg::pkg_status_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-status\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-status.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-status\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-status-options.hxx b/bpkg/pkg-status-options.hxx
new file mode 100644
index 0000000..9271c1e
--- /dev/null
+++ b/bpkg/pkg-status-options.hxx
@@ -0,0 +1,149 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_STATUS_OPTIONS_HXX
+#define BPKG_PKG_STATUS_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_status_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_status_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_status_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const bool&
+    link () const;
+
+    const bool&
+    immediate () const;
+
+    const bool&
+    recursive () const;
+
+    const bool&
+    old_available () const;
+
+    const bool&
+    constraint () const;
+
+    const bool&
+    system () const;
+
+    const bool&
+    no_hold () const;
+
+    const bool&
+    no_hold_package () const;
+
+    const bool&
+    no_hold_version () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    bool link_;
+    bool immediate_;
+    bool recursive_;
+    bool old_available_;
+    bool constraint_;
+    bool system_;
+    bool no_hold_;
+    bool no_hold_package_;
+    bool no_hold_version_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_status_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-status-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_STATUS_OPTIONS_HXX
diff --git a/bpkg/pkg-status-options.ixx b/bpkg/pkg-status-options.ixx
new file mode 100644
index 0000000..bf0c13c
--- /dev/null
+++ b/bpkg/pkg-status-options.ixx
@@ -0,0 +1,81 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_status_options
+  //
+
+  inline const bool& pkg_status_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const bool& pkg_status_options::
+  link () const
+  {
+    return this->link_;
+  }
+
+  inline const bool& pkg_status_options::
+  immediate () const
+  {
+    return this->immediate_;
+  }
+
+  inline const bool& pkg_status_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+
+  inline const bool& pkg_status_options::
+  old_available () const
+  {
+    return this->old_available_;
+  }
+
+  inline const bool& pkg_status_options::
+  constraint () const
+  {
+    return this->constraint_;
+  }
+
+  inline const bool& pkg_status_options::
+  system () const
+  {
+    return this->system_;
+  }
+
+  inline const bool& pkg_status_options::
+  no_hold () const
+  {
+    return this->no_hold_;
+  }
+
+  inline const bool& pkg_status_options::
+  no_hold_package () const
+  {
+    return this->no_hold_package_;
+  }
+
+  inline const bool& pkg_status_options::
+  no_hold_version () const
+  {
+    return this->no_hold_version_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-test-options.cxx b/bpkg/pkg-test-options.cxx
new file mode 100644
index 0000000..f5fdcf7
--- /dev/null
+++ b/bpkg/pkg-test-options.cxx
@@ -0,0 +1,758 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-test-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_test_options
+  //
+
+  pkg_test_options::
+  pkg_test_options ()
+  : all_ (),
+    all_pattern_ (),
+    all_pattern_specified_ (false),
+    immediate_ (),
+    recursive_ (),
+    package_cwd_ ()
+  {
+  }
+
+  bool pkg_test_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_test_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_test_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_test_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_test_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_test_options::
+  merge (const pkg_test_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.all_pattern_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->all_pattern_, a.all_pattern_);
+      this->all_pattern_specified_ = true;
+    }
+
+    if (a.immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->immediate_, a.immediate_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+
+    if (a.package_cwd_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->package_cwd_, a.package_cwd_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_test_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-TEST OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Test all held packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all-pattern\033[0m \033[4mpattern\033[0m     Test held packages that match the specified wildcard" << ::std::endl
+       << "                          pattern. Repeat this option to match multiple" << ::std::endl
+       << "                          patterns. Note that you may need to quote the pattern" << ::std::endl
+       << "                          to prevent expansion by your shell." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--immediate\033[0m|\033[1m-i\033[0m            Also test immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m|\033[1m-r\033[0m            Also test all dependencies, recursively." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--package-cwd\033[0m             Change the current working directory to the package" << ::std::endl
+       << "                          directory prior to running tests. This may help" << ::std::endl
+       << "                          ported third-party packages since its not uncommon" << ::std::endl
+       << "                          for tests to expect they are running form the project" << ::std::endl
+       << "                          root directory." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_test_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_test_options_map;
+
+  static _cli_pkg_test_options_map _cli_pkg_test_options_map_;
+
+  struct _cli_pkg_test_options_map_init
+  {
+    _cli_pkg_test_options_map_init ()
+    {
+      _cli_pkg_test_options_map_["--all"] =
+      &::bpkg::cli::thunk< pkg_test_options, &pkg_test_options::all_ >;
+      _cli_pkg_test_options_map_["-a"] =
+      &::bpkg::cli::thunk< pkg_test_options, &pkg_test_options::all_ >;
+      _cli_pkg_test_options_map_["--all-pattern"] =
+      &::bpkg::cli::thunk< pkg_test_options, strings, &pkg_test_options::all_pattern_,
+        &pkg_test_options::all_pattern_specified_ >;
+      _cli_pkg_test_options_map_["--immediate"] =
+      &::bpkg::cli::thunk< pkg_test_options, &pkg_test_options::immediate_ >;
+      _cli_pkg_test_options_map_["-i"] =
+      &::bpkg::cli::thunk< pkg_test_options, &pkg_test_options::immediate_ >;
+      _cli_pkg_test_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_test_options, &pkg_test_options::recursive_ >;
+      _cli_pkg_test_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_test_options, &pkg_test_options::recursive_ >;
+      _cli_pkg_test_options_map_["--package-cwd"] =
+      &::bpkg::cli::thunk< pkg_test_options, &pkg_test_options::package_cwd_ >;
+    }
+  };
+
+  static _cli_pkg_test_options_map_init _cli_pkg_test_options_map_init_;
+
+  bool pkg_test_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_test_options_map::const_iterator i (_cli_pkg_test_options_map_.find (o));
+
+    if (i != _cli_pkg_test_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_test_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_test_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-test\033[0m|\033[1mtest\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[4mpkg\033[0m..." << ::std::endl
+       << "\033[1mbpkg pkg-test\033[0m|\033[1mtest\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[1m--all\033[0m|\033[1m-a\033[0m" << ::std::endl
+       << "\033[1mbpkg pkg-test\033[0m|\033[1mtest\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] (\033[1m--all-pattern\033[0m <pattern>)...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-test\033[0m command tests the specified packages (the first form), all the" << ::std::endl
+       << "held packages (the second form, see \033[1mbpkg-pkg-status(1)\033[0m), or all the held" << ::std::endl
+       << "packages that match any of the specified wildcard patterns (the third form)." << ::std::endl
+       << "Additionally, immediate or all dependencies of these packages can also be" << ::std::endl
+       << "tested by specifying the \033[1m--immediate\033[0m|\033[1m-i\033[0m\033[0m or \033[1m--recursive\033[0m|\033[1m-r\033[0m\033[0m options," << ::std::endl
+       << "respectively. Underneath, this command doesn't do much more than run \033[1mb test\033[0m. In" << ::std::endl
+       << "the first form the specified packages must have been previously configured with" << ::std::endl
+       << "\033[1mbpkg-pkg-build(1)\033[0m or \033[1mbpkg-pkg-configure(1)\033[0m." << ::std::endl
+       << ::std::endl
+       << "Additional command line variables (\033[4mvars\033[0m, normally \033[1mconfig.*\033[0m) can be passed to" << ::std::endl
+       << "the build system. Such variables apply to all the specified packages but can" << ::std::endl
+       << "also be specified to only apply to specific packages using the argument" << ::std::endl
+       << "grouping mechanism (see \033[1mbpkg-argument-grouping(1)\033[0m for details)." << ::std::endl;
+
+    p = ::bpkg::pkg_test_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-test\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-test.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-test\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-test-options.hxx b/bpkg/pkg-test-options.hxx
new file mode 100644
index 0000000..b2c1096
--- /dev/null
+++ b/bpkg/pkg-test-options.hxx
@@ -0,0 +1,133 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_TEST_OPTIONS_HXX
+#define BPKG_PKG_TEST_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_test_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_test_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_test_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const strings&
+    all_pattern () const;
+
+    bool
+    all_pattern_specified () const;
+
+    const bool&
+    immediate () const;
+
+    const bool&
+    recursive () const;
+
+    const bool&
+    package_cwd () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    strings all_pattern_;
+    bool all_pattern_specified_;
+    bool immediate_;
+    bool recursive_;
+    bool package_cwd_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_test_usage (::std::ostream&,
+                             ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-test-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_TEST_OPTIONS_HXX
diff --git a/bpkg/pkg-test-options.ixx b/bpkg/pkg-test-options.ixx
new file mode 100644
index 0000000..5c75c56
--- /dev/null
+++ b/bpkg/pkg-test-options.ixx
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_test_options
+  //
+
+  inline const bool& pkg_test_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const strings& pkg_test_options::
+  all_pattern () const
+  {
+    return this->all_pattern_;
+  }
+
+  inline bool pkg_test_options::
+  all_pattern_specified () const
+  {
+    return this->all_pattern_specified_;
+  }
+
+  inline const bool& pkg_test_options::
+  immediate () const
+  {
+    return this->immediate_;
+  }
+
+  inline const bool& pkg_test_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+
+  inline const bool& pkg_test_options::
+  package_cwd () const
+  {
+    return this->package_cwd_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-uninstall-options.cxx b/bpkg/pkg-uninstall-options.cxx
new file mode 100644
index 0000000..611b19d
--- /dev/null
+++ b/bpkg/pkg-uninstall-options.cxx
@@ -0,0 +1,743 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-uninstall-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_uninstall_options
+  //
+
+  pkg_uninstall_options::
+  pkg_uninstall_options ()
+  : all_ (),
+    all_pattern_ (),
+    all_pattern_specified_ (false),
+    immediate_ (),
+    recursive_ ()
+  {
+  }
+
+  bool pkg_uninstall_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_uninstall_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_uninstall_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_uninstall_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_uninstall_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_uninstall_options::
+  merge (const pkg_uninstall_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.all_pattern_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->all_pattern_, a.all_pattern_);
+      this->all_pattern_specified_ = true;
+    }
+
+    if (a.immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->immediate_, a.immediate_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_uninstall_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-UNINSTALL OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Uninstall all held packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all-pattern\033[0m \033[4mpattern\033[0m     Uninstall held packages that match the specified" << ::std::endl
+       << "                          wildcard pattern. Repeat this option to match" << ::std::endl
+       << "                          multiple patterns. Note that you may need to quote" << ::std::endl
+       << "                          the pattern to prevent expansion by your shell." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--immediate\033[0m|\033[1m-i\033[0m            Also uninstall immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m|\033[1m-r\033[0m            Also uninstall all dependencies, recursively." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_uninstall_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_uninstall_options_map;
+
+  static _cli_pkg_uninstall_options_map _cli_pkg_uninstall_options_map_;
+
+  struct _cli_pkg_uninstall_options_map_init
+  {
+    _cli_pkg_uninstall_options_map_init ()
+    {
+      _cli_pkg_uninstall_options_map_["--all"] =
+      &::bpkg::cli::thunk< pkg_uninstall_options, &pkg_uninstall_options::all_ >;
+      _cli_pkg_uninstall_options_map_["-a"] =
+      &::bpkg::cli::thunk< pkg_uninstall_options, &pkg_uninstall_options::all_ >;
+      _cli_pkg_uninstall_options_map_["--all-pattern"] =
+      &::bpkg::cli::thunk< pkg_uninstall_options, strings, &pkg_uninstall_options::all_pattern_,
+        &pkg_uninstall_options::all_pattern_specified_ >;
+      _cli_pkg_uninstall_options_map_["--immediate"] =
+      &::bpkg::cli::thunk< pkg_uninstall_options, &pkg_uninstall_options::immediate_ >;
+      _cli_pkg_uninstall_options_map_["-i"] =
+      &::bpkg::cli::thunk< pkg_uninstall_options, &pkg_uninstall_options::immediate_ >;
+      _cli_pkg_uninstall_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_uninstall_options, &pkg_uninstall_options::recursive_ >;
+      _cli_pkg_uninstall_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_uninstall_options, &pkg_uninstall_options::recursive_ >;
+    }
+  };
+
+  static _cli_pkg_uninstall_options_map_init _cli_pkg_uninstall_options_map_init_;
+
+  bool pkg_uninstall_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_uninstall_options_map::const_iterator i (_cli_pkg_uninstall_options_map_.find (o));
+
+    if (i != _cli_pkg_uninstall_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_uninstall_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_uninstall_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-uninstall\033[0m|\033[1muninstall\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[4mpkg\033[0m..." << ::std::endl
+       << "\033[1mbpkg pkg-uninstall\033[0m|\033[1muninstall\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[1m--all\033[0m|\033[1m-a\033[0m" << ::std::endl
+       << "\033[1mbpkg pkg-uninstall\033[0m|\033[1muninstall\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] (\033[1m--all-pattern\033[0m <pattern>)...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-uninstall\033[0m command uninstalls the specified packages (the first form)," << ::std::endl
+       << "all the held packages (the second form, see \033[1mbpkg-pkg-status(1)\033[0m), or all the" << ::std::endl
+       << "held packages that match any of the specified wildcard patterns (the third" << ::std::endl
+       << "form). Additionally, immediate or all dependencies of these specified packages" << ::std::endl
+       << "can be also uninstalled by specifying the \033[1m--immediate\033[0m|\033[1m-i\033[0m\033[0m or \033[1m--recursive\033[0m|\033[1m-r\033[0m\033[0m" << ::std::endl
+       << "options, respectively. Underneath, this command doesn't do much more than run \033[1mb" << ::std::endl
+       << "uninstall\033[0m. In the first form the specified packages must have been previously" << ::std::endl
+       << "configured with \033[1mbpkg-pkg-build(1)\033[0m or \033[1mbpkg-pkg-configure(1)\033[0m." << ::std::endl
+       << ::std::endl
+       << "Additional command line variables (\033[4mvars\033[0m, normally \033[1mconfig.*\033[0m) can be passed to" << ::std::endl
+       << "the build system. Such variables apply to all the specified packages but can" << ::std::endl
+       << "also be specified to only apply to specific packages using the argument" << ::std::endl
+       << "grouping mechanism (see \033[1mbpkg-argument-grouping(1)\033[0m for details). See" << ::std::endl
+       << "\033[1mbpkg-pkg-install(1)\033[0m for some examples." << ::std::endl;
+
+    p = ::bpkg::pkg_uninstall_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-uninstall\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-uninstall.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-uninstall\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-uninstall-options.hxx b/bpkg/pkg-uninstall-options.hxx
new file mode 100644
index 0000000..1feb443
--- /dev/null
+++ b/bpkg/pkg-uninstall-options.hxx
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_UNINSTALL_OPTIONS_HXX
+#define BPKG_PKG_UNINSTALL_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_uninstall_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_uninstall_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_uninstall_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const strings&
+    all_pattern () const;
+
+    bool
+    all_pattern_specified () const;
+
+    const bool&
+    immediate () const;
+
+    const bool&
+    recursive () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    strings all_pattern_;
+    bool all_pattern_specified_;
+    bool immediate_;
+    bool recursive_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_uninstall_usage (::std::ostream&,
+                                  ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-uninstall-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_UNINSTALL_OPTIONS_HXX
diff --git a/bpkg/pkg-uninstall-options.ixx b/bpkg/pkg-uninstall-options.ixx
new file mode 100644
index 0000000..ef15f14
--- /dev/null
+++ b/bpkg/pkg-uninstall-options.ixx
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_uninstall_options
+  //
+
+  inline const bool& pkg_uninstall_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const strings& pkg_uninstall_options::
+  all_pattern () const
+  {
+    return this->all_pattern_;
+  }
+
+  inline bool pkg_uninstall_options::
+  all_pattern_specified () const
+  {
+    return this->all_pattern_specified_;
+  }
+
+  inline const bool& pkg_uninstall_options::
+  immediate () const
+  {
+    return this->immediate_;
+  }
+
+  inline const bool& pkg_uninstall_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-unpack-options.cxx b/bpkg/pkg-unpack-options.cxx
new file mode 100644
index 0000000..9654924
--- /dev/null
+++ b/bpkg/pkg-unpack-options.cxx
@@ -0,0 +1,741 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-unpack-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_unpack_options
+  //
+
+  pkg_unpack_options::
+  pkg_unpack_options ()
+  : existing_ (),
+    purge_ (),
+    replace_ ()
+  {
+  }
+
+  bool pkg_unpack_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_unpack_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_unpack_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_unpack_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_unpack_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_unpack_options::
+  merge (const pkg_unpack_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.existing_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->existing_, a.existing_);
+    }
+
+    if (a.purge_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->purge_, a.purge_);
+    }
+
+    if (a.replace_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->replace_, a.replace_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_unpack_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-UNPACK OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--existing\033[0m|\033[1m-e\033[0m             Treat the argument as an existing package directory" << ::std::endl
+       << "                          path rather than the package name to unpack." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--purge\033[0m|\033[1m-p\033[0m                Remove the existing package directory when the" << ::std::endl
+       << "                          package is purged." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--replace\033[0m|\033[1m-r\033[0m              Replace the source directory if the package is" << ::std::endl
+       << "                          already unpacked or fetched. Can only be specified" << ::std::endl
+       << "                          with an external package." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_unpack_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_unpack_options_map;
+
+  static _cli_pkg_unpack_options_map _cli_pkg_unpack_options_map_;
+
+  struct _cli_pkg_unpack_options_map_init
+  {
+    _cli_pkg_unpack_options_map_init ()
+    {
+      _cli_pkg_unpack_options_map_["--existing"] =
+      &::bpkg::cli::thunk< pkg_unpack_options, &pkg_unpack_options::existing_ >;
+      _cli_pkg_unpack_options_map_["-e"] =
+      &::bpkg::cli::thunk< pkg_unpack_options, &pkg_unpack_options::existing_ >;
+      _cli_pkg_unpack_options_map_["--purge"] =
+      &::bpkg::cli::thunk< pkg_unpack_options, &pkg_unpack_options::purge_ >;
+      _cli_pkg_unpack_options_map_["-p"] =
+      &::bpkg::cli::thunk< pkg_unpack_options, &pkg_unpack_options::purge_ >;
+      _cli_pkg_unpack_options_map_["--replace"] =
+      &::bpkg::cli::thunk< pkg_unpack_options, &pkg_unpack_options::replace_ >;
+      _cli_pkg_unpack_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_unpack_options, &pkg_unpack_options::replace_ >;
+    }
+  };
+
+  static _cli_pkg_unpack_options_map_init _cli_pkg_unpack_options_map_init_;
+
+  bool pkg_unpack_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_unpack_options_map::const_iterator i (_cli_pkg_unpack_options_map_.find (o));
+
+    if (i != _cli_pkg_unpack_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_unpack_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_unpack_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-unpack\033[0m [\033[4moptions\033[0m] (\033[4mpkg\033[0m[\033[1m/\033[0m\033[4mver\033[0m] | \033[1m--existing|-e\033[0m \033[4mdir\033[0m)\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "If only the package name is specified, then the \033[1mpkg-unpack\033[0m command unpacks the" << ::std::endl
+       << "archive for the previously fetched (\033[1mbpkg-pkg-fetch(1)\033[0m) package. The resulting" << ::std::endl
+       << "package state is \033[1munpacked\033[0m (\033[1mbpkg-pkg-status(1)\033[0m)." << ::std::endl
+       << ::std::endl
+       << "If the package version is also specified, then the (source) directory from one" << ::std::endl
+       << "of the directory-based repositories (\033[1mbpkg-rep-add(1)\033[0m) is used in place, without" << ::std::endl
+       << "copying it into the configuration directory. Such a package is called \033[4mexternal\033[0m." << ::std::endl
+       << ::std::endl
+       << "If the \033[1m--existing|-e\033[0m option is used, then instead of the package name," << ::std::endl
+       << "\033[1mpkg-unpack\033[0m expects a local path to an existing package directory. In this case," << ::std::endl
+       << "\033[1mbpkg\033[0m will use the (source) directory in place, the same as for packages from" << ::std::endl
+       << "directory-based repositories. Also, unless the \033[1m--purge|-p\033[0m option is specified," << ::std::endl
+       << "\033[1mbpkg\033[0m will not attempt to remove this directory when the package is later purged" << ::std::endl
+       << "with the \033[1mbpkg-pkg-purge(1)\033[0m command. Such a package is also \033[4mexternal\033[0m." << ::std::endl
+       << ::std::endl
+       << "If \033[1m--existing|-e\033[0m is specified together with the \033[1m--replace|-r\033[0m option, then" << ::std::endl
+       << "\033[1mpkg-unpack\033[0m will replace the archive and/or source directory of a package that" << ::std::endl
+       << "is already in the \033[1munpacked\033[0m or \033[1mfetched\033[0m state." << ::std::endl
+       << ::std::endl
+       << "An external package triggers several changes in semantics compared to a normal" << ::std::endl
+       << "package: The package (output) directory inside the configuration is called just" << ::std::endl
+       << "\033[4mpkg\033[0m rather than \033[4mpkg\033[0m\033[1m-\033[0m\033[4mver\033[0m. It is also assumed that the packaging information" << ::std::endl
+       << "(package manifest and lockfile) for such packages may change without" << ::std::endl
+       << "incrementing the package version (for example, during development). To support" << ::std::endl
+       << "this, \033[1mbpkg\033[0m implements the \033[4mpackage iteration\033[0m mechanism which may result in" << ::std::endl
+       << "iteration numbers to be shown as part of the package version, for example," << ::std::endl
+       << "\033[1m1.2.3#1\033[0m (see Package Version (bpkg#package-version))." << ::std::endl;
+
+    p = ::bpkg::pkg_unpack_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-unpack\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-unpack.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-unpack\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl
+       << "--purge|-p" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-unpack-options.hxx b/bpkg/pkg-unpack-options.hxx
new file mode 100644
index 0000000..752e17b
--- /dev/null
+++ b/bpkg/pkg-unpack-options.hxx
@@ -0,0 +1,121 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_UNPACK_OPTIONS_HXX
+#define BPKG_PKG_UNPACK_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_unpack_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_unpack_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_unpack_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    existing () const;
+
+    const bool&
+    purge () const;
+
+    const bool&
+    replace () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool existing_;
+    bool purge_;
+    bool replace_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_unpack_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-unpack-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_UNPACK_OPTIONS_HXX
diff --git a/bpkg/pkg-unpack-options.ixx b/bpkg/pkg-unpack-options.ixx
new file mode 100644
index 0000000..68abf8a
--- /dev/null
+++ b/bpkg/pkg-unpack-options.ixx
@@ -0,0 +1,39 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_unpack_options
+  //
+
+  inline const bool& pkg_unpack_options::
+  existing () const
+  {
+    return this->existing_;
+  }
+
+  inline const bool& pkg_unpack_options::
+  purge () const
+  {
+    return this->purge_;
+  }
+
+  inline const bool& pkg_unpack_options::
+  replace () const
+  {
+    return this->replace_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-update-options.cxx b/bpkg/pkg-update-options.cxx
new file mode 100644
index 0000000..0dc6187
--- /dev/null
+++ b/bpkg/pkg-update-options.cxx
@@ -0,0 +1,763 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-update-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_update_options
+  //
+
+  pkg_update_options::
+  pkg_update_options ()
+  : all_ (),
+    all_pattern_ (),
+    all_pattern_specified_ (false),
+    immediate_ (),
+    recursive_ (),
+    for__ (),
+    for__specified_ (false)
+  {
+  }
+
+  bool pkg_update_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_update_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_update_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_update_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_update_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_update_options::
+  merge (const pkg_update_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.all_pattern_specified_)
+    {
+      ::bpkg::cli::parser< strings>::merge (
+        this->all_pattern_, a.all_pattern_);
+      this->all_pattern_specified_ = true;
+    }
+
+    if (a.immediate_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->immediate_, a.immediate_);
+    }
+
+    if (a.recursive_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->recursive_, a.recursive_);
+    }
+
+    if (a.for__specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->for__, a.for__);
+      this->for__specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_update_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-UPDATE OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Update all held packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all-pattern\033[0m \033[4mpattern\033[0m     Update held packages that match the specified" << ::std::endl
+       << "                          wildcard pattern. Repeat this option to match" << ::std::endl
+       << "                          multiple patterns. Note that you may need to quote" << ::std::endl
+       << "                          the pattern to prevent expansion by your shell." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--immediate\033[0m|\033[1m-i\033[0m            Also update immediate dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--recursive\033[0m|\033[1m-r\033[0m            Also update all dependencies, recursively." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--for\033[0m|\033[1m-f\033[0m \033[4moperation\033[0m        Instead of the default \033[1mupdate\033[0m build system operation," << ::std::endl
+       << "                          perform the \033[1mupdate-for-\033[0m\033[4moperation\033[0m variant where" << ::std::endl
+       << "                          \033[4moperation\033[0m is normally \033[1minstall\033[0m or \033[1mtest\033[0m." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_update_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_update_options_map;
+
+  static _cli_pkg_update_options_map _cli_pkg_update_options_map_;
+
+  struct _cli_pkg_update_options_map_init
+  {
+    _cli_pkg_update_options_map_init ()
+    {
+      _cli_pkg_update_options_map_["--all"] =
+      &::bpkg::cli::thunk< pkg_update_options, &pkg_update_options::all_ >;
+      _cli_pkg_update_options_map_["-a"] =
+      &::bpkg::cli::thunk< pkg_update_options, &pkg_update_options::all_ >;
+      _cli_pkg_update_options_map_["--all-pattern"] =
+      &::bpkg::cli::thunk< pkg_update_options, strings, &pkg_update_options::all_pattern_,
+        &pkg_update_options::all_pattern_specified_ >;
+      _cli_pkg_update_options_map_["--immediate"] =
+      &::bpkg::cli::thunk< pkg_update_options, &pkg_update_options::immediate_ >;
+      _cli_pkg_update_options_map_["-i"] =
+      &::bpkg::cli::thunk< pkg_update_options, &pkg_update_options::immediate_ >;
+      _cli_pkg_update_options_map_["--recursive"] =
+      &::bpkg::cli::thunk< pkg_update_options, &pkg_update_options::recursive_ >;
+      _cli_pkg_update_options_map_["-r"] =
+      &::bpkg::cli::thunk< pkg_update_options, &pkg_update_options::recursive_ >;
+      _cli_pkg_update_options_map_["--for"] =
+      &::bpkg::cli::thunk< pkg_update_options, string, &pkg_update_options::for__,
+        &pkg_update_options::for__specified_ >;
+      _cli_pkg_update_options_map_["-f"] =
+      &::bpkg::cli::thunk< pkg_update_options, string, &pkg_update_options::for__,
+        &pkg_update_options::for__specified_ >;
+    }
+  };
+
+  static _cli_pkg_update_options_map_init _cli_pkg_update_options_map_init_;
+
+  bool pkg_update_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_update_options_map::const_iterator i (_cli_pkg_update_options_map_.find (o));
+
+    if (i != _cli_pkg_update_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_update_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_update_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-update\033[0m|\033[1mupdate\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[4mpkg\033[0m..." << ::std::endl
+       << "\033[1mbpkg pkg-update\033[0m|\033[1mupdate\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] \033[1m--all\033[0m|\033[1m-a\033[0m" << ::std::endl
+       << "\033[1mbpkg pkg-update\033[0m|\033[1mupdate\033[0m [\033[4moptions\033[0m] [\033[4mvars\033[0m] (\033[1m--all-pattern\033[0m <pattern>)...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-update\033[0m command updates the specified packages (the first form), all the" << ::std::endl
+       << "held packages (the second form, see \033[1mbpkg-pkg-status(1)\033[0m), or all the held" << ::std::endl
+       << "packages that match any of the specified wildcard patterns (the third form)." << ::std::endl
+       << "Additionally, immediate or all dependencies of these packages can be also" << ::std::endl
+       << "updated by specifying the \033[1m--immediate\033[0m|\033[1m-i\033[0m\033[0m or \033[1m--recursive\033[0m|\033[1m-r\033[0m\033[0m options," << ::std::endl
+       << "respectively. Underneath, this command doesn't do much more than run \033[1mb update\033[0m" << ::std::endl
+       << "(or one of its update-for-*\033[0m variants; see \033[1m--for|-f\033[0m). In the first form the" << ::std::endl
+       << "specified packages must have been previously configured with \033[1mbpkg-pkg-build(1)\033[0m" << ::std::endl
+       << "or \033[1mbpkg-pkg-configure(1)\033[0m." << ::std::endl
+       << ::std::endl
+       << "Additional command line variables (\033[4mvars\033[0m, normally \033[1mconfig.*\033[0m) can be passed to" << ::std::endl
+       << "the build system. Such variables apply to all the specified packages but can" << ::std::endl
+       << "also be specified to only apply to specific packages using the argument" << ::std::endl
+       << "grouping mechanism (see \033[1mbpkg-argument-grouping(1)\033[0m for details)." << ::std::endl;
+
+    p = ::bpkg::pkg_update_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-update\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-update.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mpkg-update\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-update-options.hxx b/bpkg/pkg-update-options.hxx
new file mode 100644
index 0000000..291af69
--- /dev/null
+++ b/bpkg/pkg-update-options.hxx
@@ -0,0 +1,137 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_UPDATE_OPTIONS_HXX
+#define BPKG_PKG_UPDATE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class pkg_update_options: public ::bpkg::configuration_options
+  {
+    public:
+    pkg_update_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_update_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const strings&
+    all_pattern () const;
+
+    bool
+    all_pattern_specified () const;
+
+    const bool&
+    immediate () const;
+
+    const bool&
+    recursive () const;
+
+    const string&
+    for_ () const;
+
+    bool
+    for__specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    strings all_pattern_;
+    bool all_pattern_specified_;
+    bool immediate_;
+    bool recursive_;
+    string for__;
+    bool for__specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_update_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-update-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_UPDATE_OPTIONS_HXX
diff --git a/bpkg/pkg-update-options.ixx b/bpkg/pkg-update-options.ixx
new file mode 100644
index 0000000..d90eb44
--- /dev/null
+++ b/bpkg/pkg-update-options.ixx
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_update_options
+  //
+
+  inline const bool& pkg_update_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const strings& pkg_update_options::
+  all_pattern () const
+  {
+    return this->all_pattern_;
+  }
+
+  inline bool pkg_update_options::
+  all_pattern_specified () const
+  {
+    return this->all_pattern_specified_;
+  }
+
+  inline const bool& pkg_update_options::
+  immediate () const
+  {
+    return this->immediate_;
+  }
+
+  inline const bool& pkg_update_options::
+  recursive () const
+  {
+    return this->recursive_;
+  }
+
+  inline const string& pkg_update_options::
+  for_ () const
+  {
+    return this->for__;
+  }
+
+  inline bool pkg_update_options::
+  for__specified () const
+  {
+    return this->for__specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/pkg-verify-options.cxx b/bpkg/pkg-verify-options.cxx
new file mode 100644
index 0000000..8d5bc18
--- /dev/null
+++ b/bpkg/pkg-verify-options.cxx
@@ -0,0 +1,731 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/pkg-verify-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // pkg_verify_options
+  //
+
+  pkg_verify_options::
+  pkg_verify_options ()
+  : silent_ (),
+    deep_ (),
+    ignore_unknown_ (),
+    manifest_ ()
+  {
+  }
+
+  bool pkg_verify_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_verify_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool pkg_verify_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_verify_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool pkg_verify_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void pkg_verify_options::
+  merge (const pkg_verify_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+
+    if (a.silent_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->silent_, a.silent_);
+    }
+
+    if (a.deep_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->deep_, a.deep_);
+    }
+
+    if (a.ignore_unknown_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->ignore_unknown_, a.ignore_unknown_);
+    }
+
+    if (a.manifest_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->manifest_, a.manifest_);
+    }
+  }
+
+  ::bpkg::cli::usage_para pkg_verify_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mPKG-VERIFY OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--silent\033[0m                  Suppress the error messages about the reason why the" << ::std::endl
+       << "                          package is invalid. Just return the error status." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--deep\033[0m                    Verify the presence of the required *-build\033[0m" << ::std::endl
+       << "                          values/files and the validity of files referenced by" << ::std::endl
+       << "                          the \033[1m*-file\033[0m manifest values." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--ignore-unknown\033[0m          Ignore unknown manifest entries. By default, \033[1mbpkg\033[0m" << ::std::endl
+       << "                          will refuse to declare such a package valid since it" << ::std::endl
+       << "                          cannot be sure the unknown entries are valid. Note" << ::std::endl
+       << "                          that this option also ignores the version constraints" << ::std::endl
+       << "                          in the special toolchain build-time dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--manifest\033[0m                Instead of printing the successful verification" << ::std::endl
+       << "                          result in the human-readable form, dump the package" << ::std::endl
+       << "                          manifest to \033[1mstdout\033[0m. If the \033[1m--deep\033[0m option is" << ::std::endl
+       << "                          specified, then in the resulting manifest the \033[1m*-file\033[0m" << ::std::endl
+       << "                          values are replaced with the contents of the" << ::std::endl
+       << "                          referenced files, the *-build\033[0m values are" << ::std::endl
+       << "                          automatically added (unless the corresponding files" << ::std::endl
+       << "                          are absent), and the package dependency constraints" << ::std::endl
+       << "                          are completed." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (pkg_verify_options&, ::bpkg::cli::scanner&)>
+  _cli_pkg_verify_options_map;
+
+  static _cli_pkg_verify_options_map _cli_pkg_verify_options_map_;
+
+  struct _cli_pkg_verify_options_map_init
+  {
+    _cli_pkg_verify_options_map_init ()
+    {
+      _cli_pkg_verify_options_map_["--silent"] =
+      &::bpkg::cli::thunk< pkg_verify_options, &pkg_verify_options::silent_ >;
+      _cli_pkg_verify_options_map_["--deep"] =
+      &::bpkg::cli::thunk< pkg_verify_options, &pkg_verify_options::deep_ >;
+      _cli_pkg_verify_options_map_["--ignore-unknown"] =
+      &::bpkg::cli::thunk< pkg_verify_options, &pkg_verify_options::ignore_unknown_ >;
+      _cli_pkg_verify_options_map_["--manifest"] =
+      &::bpkg::cli::thunk< pkg_verify_options, &pkg_verify_options::manifest_ >;
+    }
+  };
+
+  static _cli_pkg_verify_options_map_init _cli_pkg_verify_options_map_init_;
+
+  bool pkg_verify_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_pkg_verify_options_map::const_iterator i (_cli_pkg_verify_options_map_.find (o));
+
+    if (i != _cli_pkg_verify_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool pkg_verify_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_verify_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg pkg-verify\033[0m [\033[4moptions\033[0m] \033[4mfile\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mpkg-verify\033[0m command verifies that the specified archive file is a valid" << ::std::endl
+       << "\033[1mbpkg\033[0m package. Specifically, it checks that the file's name and the top-level" << ::std::endl
+       << "directory inside the archive match the canonical \033[4mname\033[0m\033[1m-\033[0m\033[4mversion\033[0m\033[0m form and that" << ::std::endl
+       << "there is a valid manifest file in that top-level directory. Additionally, if" << ::std::endl
+       << "the \033[1m--deep\033[0m option is specified, it also checks that the required *-build\033[0m" << ::std::endl
+       << "values/files are present in the manifest/archive and the files referenced by" << ::std::endl
+       << "the \033[1m*-file\033[0m manifest values are present in the archive and are not empty." << ::std::endl;
+
+    p = ::bpkg::pkg_verify_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-verify\033[0m command the following options files are searched for in the" << ::std::endl
+       << "predefined directories (system, etc) and, if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-pkg-verify.options" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/pkg-verify-options.hxx b/bpkg/pkg-verify-options.hxx
new file mode 100644
index 0000000..d4b1415
--- /dev/null
+++ b/bpkg/pkg-verify-options.hxx
@@ -0,0 +1,125 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_PKG_VERIFY_OPTIONS_HXX
+#define BPKG_PKG_VERIFY_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class pkg_verify_options: public ::bpkg::common_options
+  {
+    public:
+    pkg_verify_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const pkg_verify_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    silent () const;
+
+    const bool&
+    deep () const;
+
+    const bool&
+    ignore_unknown () const;
+
+    const bool&
+    manifest () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool silent_;
+    bool deep_;
+    bool ignore_unknown_;
+    bool manifest_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_pkg_verify_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/pkg-verify-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_PKG_VERIFY_OPTIONS_HXX
diff --git a/bpkg/pkg-verify-options.ixx b/bpkg/pkg-verify-options.ixx
new file mode 100644
index 0000000..4e66b5a
--- /dev/null
+++ b/bpkg/pkg-verify-options.ixx
@@ -0,0 +1,45 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // pkg_verify_options
+  //
+
+  inline const bool& pkg_verify_options::
+  silent () const
+  {
+    return this->silent_;
+  }
+
+  inline const bool& pkg_verify_options::
+  deep () const
+  {
+    return this->deep_;
+  }
+
+  inline const bool& pkg_verify_options::
+  ignore_unknown () const
+  {
+    return this->ignore_unknown_;
+  }
+
+  inline const bool& pkg_verify_options::
+  manifest () const
+  {
+    return this->manifest_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/rep-add-options.cxx b/bpkg/rep-add-options.cxx
new file mode 100644
index 0000000..194a5d7
--- /dev/null
+++ b/bpkg/rep-add-options.cxx
@@ -0,0 +1,703 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/rep-add-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // rep_add_options
+  //
+
+  rep_add_options::
+  rep_add_options ()
+  : type_ (),
+    type_specified_ (false)
+  {
+  }
+
+  bool rep_add_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_add_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_add_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_add_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_add_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void rep_add_options::
+  merge (const rep_add_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.type_specified_)
+    {
+      ::bpkg::cli::parser< repository_type>::merge (
+        this->type_, a.type_);
+      this->type_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para rep_add_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mREP-ADD OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--type\033[0m \033[4mtype\033[0m               Specify the repository type with valid values being" << ::std::endl
+       << "                          \033[1mpkg\033[0m, \033[1mdir\033[0m, and \033[1mgit\033[0m." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rep_add_options&, ::bpkg::cli::scanner&)>
+  _cli_rep_add_options_map;
+
+  static _cli_rep_add_options_map _cli_rep_add_options_map_;
+
+  struct _cli_rep_add_options_map_init
+  {
+    _cli_rep_add_options_map_init ()
+    {
+      _cli_rep_add_options_map_["--type"] =
+      &::bpkg::cli::thunk< rep_add_options, repository_type, &rep_add_options::type_,
+        &rep_add_options::type_specified_ >;
+    }
+  };
+
+  static _cli_rep_add_options_map_init _cli_rep_add_options_map_init_;
+
+  bool rep_add_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_rep_add_options_map::const_iterator i (_cli_rep_add_options_map_.find (o));
+
+    if (i != _cli_rep_add_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool rep_add_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_add_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg rep-add\033[0m|\033[1madd\033[0m [\033[4moptions\033[0m] \033[4mrep-loc\033[0m...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mrep-add\033[0m command adds the specified package repositories to the" << ::std::endl
+       << "configuration. The repository location \033[4mrep-loc\033[0m is a URL or a directory path. If" << ::std::endl
+       << "a repository with the same canonical name already exists in the configuration," << ::std::endl
+       << "then its location is replaced with the specified." << ::std::endl
+       << ::std::endl
+       << "Note that this command doesn't fetch the list of available packages for the" << ::std::endl
+       << "newly added repository. For that, use the \033[1mbpkg-rep-fetch(1)\033[0m command, normally," << ::std::endl
+       << "after adding all the repositories you wish to use." << ::std::endl
+       << ::std::endl
+       << "Currently three types of repositories are supported: archive-based \033[1mpkg\033[0m," << ::std::endl
+       << "directory-based \033[1mdir\033[0m, and version control-based \033[1mgit\033[0m. See" << ::std::endl
+       << "\033[1mbpkg-repository-types(1)\033[0m for details on their structure and URL format." << ::std::endl
+       << ::std::endl
+       << "Normally the repository type can be automatically guessed by examining its URL" << ::std::endl
+       << "(for example, the presence of the \033[1m.git\033[0m extension) or, in case of a local" << ::std::endl
+       << "repository, its content (for example, the presence of the \033[1m.git/\033[0m subdirectory)." << ::std::endl
+       << "Without any identifying information the \033[1mpkg\033[0m type is assumed unless explicitly" << ::std::endl
+       << "specified with the \033[1m--type\033[0m option or in the URL scheme. Note, however, that the" << ::std::endl
+       << "\033[1mdir\033[0m repository type is never guessed since it is not easily distinguishable" << ::std::endl
+       << "from local \033[1mpkg\033[0m and \033[1mgit\033[0m repositories." << ::std::endl;
+
+    p = ::bpkg::rep_add_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mrep-add\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-rep-add.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mrep-add\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/rep-add-options.hxx b/bpkg/rep-add-options.hxx
new file mode 100644
index 0000000..9e257c6
--- /dev/null
+++ b/bpkg/rep-add-options.hxx
@@ -0,0 +1,119 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REP_ADD_OPTIONS_HXX
+#define BPKG_REP_ADD_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <libbpkg/manifest.hxx>
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class rep_add_options: public ::bpkg::configuration_options
+  {
+    public:
+    rep_add_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const rep_add_options&);
+
+    // Option accessors.
+    //
+    const repository_type&
+    type () const;
+
+    bool
+    type_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    repository_type type_;
+    bool type_specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_add_usage (::std::ostream&,
+                            ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/rep-add-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REP_ADD_OPTIONS_HXX
diff --git a/bpkg/rep-add-options.ixx b/bpkg/rep-add-options.ixx
new file mode 100644
index 0000000..bfaa70f
--- /dev/null
+++ b/bpkg/rep-add-options.ixx
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // rep_add_options
+  //
+
+  inline const repository_type& rep_add_options::
+  type () const
+  {
+    return this->type_;
+  }
+
+  inline bool rep_add_options::
+  type_specified () const
+  {
+    return this->type_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/rep-create-options.cxx b/bpkg/rep-create-options.cxx
new file mode 100644
index 0000000..3c8c1d1
--- /dev/null
+++ b/bpkg/rep-create-options.cxx
@@ -0,0 +1,727 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/rep-create-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // rep_create_options
+  //
+
+  rep_create_options::
+  rep_create_options ()
+  : ignore_unknown_ (),
+    min_bpkg_version_ (),
+    min_bpkg_version_specified_ (false),
+    key_ (),
+    key_specified_ (false)
+  {
+  }
+
+  bool rep_create_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_create_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_create_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_create_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_create_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void rep_create_options::
+  merge (const rep_create_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+
+    if (a.ignore_unknown_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->ignore_unknown_, a.ignore_unknown_);
+    }
+
+    if (a.min_bpkg_version_specified_)
+    {
+      ::bpkg::cli::parser< butl::standard_version>::merge (
+        this->min_bpkg_version_, a.min_bpkg_version_);
+      this->min_bpkg_version_specified_ = true;
+    }
+
+    if (a.key_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->key_, a.key_);
+      this->key_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para rep_create_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mREP-CREATE OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--ignore-unknown\033[0m          Ignore unknown manifest entries. Note that this" << ::std::endl
+       << "                          option also ignores the version constraints in the" << ::std::endl
+       << "                          special toolchain build-time dependencies." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--min-bpkg-version\033[0m \033[4mver\033[0m    Apply backward compatibility workarounds to the" << ::std::endl
+       << "                          generated \033[1mpackages.manifest\033[0m file so that it can be" << ::std::endl
+       << "                          consumed by \033[1mbpkg\033[0m versions greater or equal to the" << ::std::endl
+       << "                          specified version. If unspecified, then the" << ::std::endl
+       << "                          \033[1mmin-bpkg-version\033[0m value from the" << ::std::endl
+       << "                          \033[1mrepositories.manifest\033[0m file is used, if present. If" << ::std::endl
+       << "                          the manifest value is not specified either, then no" << ::std::endl
+       << "                          backward compatibility workarounds are applied." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--key\033[0m \033[4mname\033[0m                Private key to use to sign the repository. In most" << ::std::endl
+       << "                          cases \033[4mname\033[0m will be a path to the key file but it can" << ::std::endl
+       << "                          also be a key id when a custom \033[1mopenssl\033[0m cryptographic" << ::std::endl
+       << "                          engine is used." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rep_create_options&, ::bpkg::cli::scanner&)>
+  _cli_rep_create_options_map;
+
+  static _cli_rep_create_options_map _cli_rep_create_options_map_;
+
+  struct _cli_rep_create_options_map_init
+  {
+    _cli_rep_create_options_map_init ()
+    {
+      _cli_rep_create_options_map_["--ignore-unknown"] =
+      &::bpkg::cli::thunk< rep_create_options, &rep_create_options::ignore_unknown_ >;
+      _cli_rep_create_options_map_["--min-bpkg-version"] =
+      &::bpkg::cli::thunk< rep_create_options, butl::standard_version, &rep_create_options::min_bpkg_version_,
+        &rep_create_options::min_bpkg_version_specified_ >;
+      _cli_rep_create_options_map_["--key"] =
+      &::bpkg::cli::thunk< rep_create_options, string, &rep_create_options::key_,
+        &rep_create_options::key_specified_ >;
+    }
+  };
+
+  static _cli_rep_create_options_map_init _cli_rep_create_options_map_init_;
+
+  bool rep_create_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_rep_create_options_map::const_iterator i (_cli_rep_create_options_map_.find (o));
+
+    if (i != _cli_rep_create_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool rep_create_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_create_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg rep-create\033[0m [\033[4moptions\033[0m] [\033[4mdir\033[0m]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mrep-create\033[0m command regenerates the \033[1mpackages.manifest\033[0m file based on the" << ::std::endl
+       << "files present in the repository directory. If the \033[1mrepositories.manifest\033[0m file" << ::std::endl
+       << "contains a certificate, then the \033[1msignature.manifest\033[0m file is regenerated as" << ::std::endl
+       << "well. In this case the \033[1m--key\033[0m option must be used to specify the certificate's" << ::std::endl
+       << "private key. If \033[4mdir\033[0m is not specified, then the current working directory is" << ::std::endl
+       << "used as the repository root." << ::std::endl;
+
+    p = ::bpkg::rep_create_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mrep-create\033[0m command the search start directory is the repository" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-rep-create.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mrep-create\033[0m command options cannot be specified in the remote" << ::std::endl
+       << "default options files:" << ::std::endl
+       << ::std::endl
+       << "--key" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/rep-create-options.hxx b/bpkg/rep-create-options.hxx
new file mode 100644
index 0000000..9afb227
--- /dev/null
+++ b/bpkg/rep-create-options.hxx
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REP_CREATE_OPTIONS_HXX
+#define BPKG_REP_CREATE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class rep_create_options: public ::bpkg::common_options
+  {
+    public:
+    rep_create_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const rep_create_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    ignore_unknown () const;
+
+    const butl::standard_version&
+    min_bpkg_version () const;
+
+    bool
+    min_bpkg_version_specified () const;
+
+    const string&
+    key () const;
+
+    bool
+    key_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool ignore_unknown_;
+    butl::standard_version min_bpkg_version_;
+    bool min_bpkg_version_specified_;
+    string key_;
+    bool key_specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_create_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/rep-create-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REP_CREATE_OPTIONS_HXX
diff --git a/bpkg/rep-create-options.ixx b/bpkg/rep-create-options.ixx
new file mode 100644
index 0000000..cf0a734
--- /dev/null
+++ b/bpkg/rep-create-options.ixx
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // rep_create_options
+  //
+
+  inline const bool& rep_create_options::
+  ignore_unknown () const
+  {
+    return this->ignore_unknown_;
+  }
+
+  inline const butl::standard_version& rep_create_options::
+  min_bpkg_version () const
+  {
+    return this->min_bpkg_version_;
+  }
+
+  inline bool rep_create_options::
+  min_bpkg_version_specified () const
+  {
+    return this->min_bpkg_version_specified_;
+  }
+
+  inline const string& rep_create_options::
+  key () const
+  {
+    return this->key_;
+  }
+
+  inline bool rep_create_options::
+  key_specified () const
+  {
+    return this->key_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/rep-fetch-options.cxx b/bpkg/rep-fetch-options.cxx
new file mode 100644
index 0000000..a9f336d
--- /dev/null
+++ b/bpkg/rep-fetch-options.cxx
@@ -0,0 +1,694 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/rep-fetch-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // rep_fetch_options
+  //
+
+  rep_fetch_options::
+  rep_fetch_options ()
+  : shallow_ ()
+  {
+  }
+
+  bool rep_fetch_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_fetch_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_fetch_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_fetch_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_fetch_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void rep_fetch_options::
+  merge (const rep_fetch_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.shallow_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->shallow_, a.shallow_);
+    }
+  }
+
+  ::bpkg::cli::usage_para rep_fetch_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mREP-FETCH OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--shallow\033[0m                 Do not re-fetch complement and prerequisite" << ::std::endl
+       << "                          repositories of the specified repositories unless the" << ::std::endl
+       << "                          set of complements and/or prerequisites has changed." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rep_fetch_options&, ::bpkg::cli::scanner&)>
+  _cli_rep_fetch_options_map;
+
+  static _cli_rep_fetch_options_map _cli_rep_fetch_options_map_;
+
+  struct _cli_rep_fetch_options_map_init
+  {
+    _cli_rep_fetch_options_map_init ()
+    {
+      _cli_rep_fetch_options_map_["--shallow"] =
+      &::bpkg::cli::thunk< rep_fetch_options, &rep_fetch_options::shallow_ >;
+    }
+  };
+
+  static _cli_rep_fetch_options_map_init _cli_rep_fetch_options_map_init_;
+
+  bool rep_fetch_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_rep_fetch_options_map::const_iterator i (_cli_rep_fetch_options_map_.find (o));
+
+    if (i != _cli_rep_fetch_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool rep_fetch_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_fetch_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg rep-fetch\033[0m|\033[1mfetch\033[0m [\033[4moptions\033[0m] [(\033[4mrep-name\033[0m | \033[4mrep-loc\033[0m)...]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mrep-fetch\033[0m command fetches the list of available packages for the specified" << ::std::endl
+       << "repositories as well as all their complement and prerequisite repositories," << ::std::endl
+       << "recursively. If no repositories were specified, then all the repositories" << ::std::endl
+       << "previously added (\033[1mbpkg-rep-add(1)\033[0m) to the configuration are fetched." << ::std::endl
+       << ::std::endl
+       << "The repository to fetch can be specified either as a repository name or as a" << ::std::endl
+       << "repository location (URL or a directory path; see \033[1mbpkg-rep-add(1)\033[0m for details)." << ::std::endl
+       << "In the latter case, the repository location is added/replaced as if by first" << ::std::endl
+       << "executing the \033[1mrep-add\033[0m command." << ::std::endl
+       << ::std::endl
+       << "Note that fetching only a specific repository that happens to be a prerequisite" << ::std::endl
+       << "or complete of another repository not being fetched may result in an" << ::std::endl
+       << "inconsistent repository state." << ::std::endl;
+
+    p = ::bpkg::rep_fetch_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mrep-fetch\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-rep-fetch.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mrep-fetch\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/rep-fetch-options.hxx b/bpkg/rep-fetch-options.hxx
new file mode 100644
index 0000000..01ed16e
--- /dev/null
+++ b/bpkg/rep-fetch-options.hxx
@@ -0,0 +1,113 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REP_FETCH_OPTIONS_HXX
+#define BPKG_REP_FETCH_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class rep_fetch_options: public ::bpkg::configuration_options
+  {
+    public:
+    rep_fetch_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const rep_fetch_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    shallow () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool shallow_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_fetch_usage (::std::ostream&,
+                              ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/rep-fetch-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REP_FETCH_OPTIONS_HXX
diff --git a/bpkg/rep-fetch-options.ixx b/bpkg/rep-fetch-options.ixx
new file mode 100644
index 0000000..283f304
--- /dev/null
+++ b/bpkg/rep-fetch-options.ixx
@@ -0,0 +1,27 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // rep_fetch_options
+  //
+
+  inline const bool& rep_fetch_options::
+  shallow () const
+  {
+    return this->shallow_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/rep-info-options.cxx b/bpkg/rep-info-options.cxx
new file mode 100644
index 0000000..e714f2e
--- /dev/null
+++ b/bpkg/rep-info-options.cxx
@@ -0,0 +1,902 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/rep-info-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // rep_info_options
+  //
+
+  rep_info_options::
+  rep_info_options ()
+  : name_ (),
+    cert_fingerprint_ (),
+    cert_name_ (),
+    cert_organization_ (),
+    cert_email_ (),
+    repositories_ (),
+    packages_ (),
+    manifest_ (),
+    ignore_unknown_ (),
+    deep_ (),
+    repositories_file_ (),
+    repositories_file_specified_ (false),
+    packages_file_ (),
+    packages_file_specified_ (false),
+    type_ (),
+    type_specified_ (false),
+    directory_ (),
+    directory_specified_ (false)
+  {
+  }
+
+  bool rep_info_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_info_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_info_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_info_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_info_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void rep_info_options::
+  merge (const rep_info_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // common_options base
+    //
+    ::bpkg::common_options::merge (a);
+
+    if (a.name_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->name_, a.name_);
+    }
+
+    if (a.cert_fingerprint_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cert_fingerprint_, a.cert_fingerprint_);
+    }
+
+    if (a.cert_name_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cert_name_, a.cert_name_);
+    }
+
+    if (a.cert_organization_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cert_organization_, a.cert_organization_);
+    }
+
+    if (a.cert_email_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->cert_email_, a.cert_email_);
+    }
+
+    if (a.repositories_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->repositories_, a.repositories_);
+    }
+
+    if (a.packages_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->packages_, a.packages_);
+    }
+
+    if (a.manifest_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->manifest_, a.manifest_);
+    }
+
+    if (a.ignore_unknown_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->ignore_unknown_, a.ignore_unknown_);
+    }
+
+    if (a.deep_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->deep_, a.deep_);
+    }
+
+    if (a.repositories_file_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->repositories_file_, a.repositories_file_);
+      this->repositories_file_specified_ = true;
+    }
+
+    if (a.packages_file_specified_)
+    {
+      ::bpkg::cli::parser< path>::merge (
+        this->packages_file_, a.packages_file_);
+      this->packages_file_specified_ = true;
+    }
+
+    if (a.type_specified_)
+    {
+      ::bpkg::cli::parser< repository_type>::merge (
+        this->type_, a.type_);
+      this->type_specified_ = true;
+    }
+
+    if (a.directory_specified_)
+    {
+      ::bpkg::cli::parser< string>::merge (
+        this->directory_, a.directory_);
+      this->directory_specified_ = true;
+    }
+  }
+
+  ::bpkg::cli::usage_para rep_info_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mREP-INFO OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--name\033[0m|\033[1m-n\033[0m                 Print the repository's name and location." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--cert-fingerprint\033[0m        Print the repository's certificate fingerprint or" << ::std::endl
+       << "                          empty line if the repository is unsigned." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--cert-name\033[0m               Print the repository's certificate common name (CN)" << ::std::endl
+       << "                          or empty line if the repository is unsigned." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--cert-organization\033[0m       Print the repository's certificate organization name" << ::std::endl
+       << "                          (O) or empty line if the repository is unsigned." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--cert-email\033[0m              Print the repository's certificate email or empty" << ::std::endl
+       << "                          line if the repository is unsigned." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--repositories\033[0m|\033[1m-r\033[0m         Print the list of complement and prerequisite" << ::std::endl
+       << "                          repositories." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--packages\033[0m|\033[1m-p\033[0m             Print the list of available packages." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--manifest\033[0m                Instead of printing the information in the" << ::std::endl
+       << "                          human-readable form, dump it (to \033[1mstdout\033[0m) as" << ::std::endl
+       << "                          manifest(s). Normally you would use this option in" << ::std::endl
+       << "                          combination with \033[1m--packages|-p\033[0m or \033[1m--repositories|-r\033[0m" << ::std::endl
+       << "                          to only dump one of the manifests. If the \033[1m--deep\033[0m" << ::std::endl
+       << "                          option is specified, then in the resulting packages" << ::std::endl
+       << "                          manifest the \033[1m*-file\033[0m values are replaced with the" << ::std::endl
+       << "                          contents of the referenced files and the *-build\033[0m" << ::std::endl
+       << "                          values are automatically added (unless the" << ::std::endl
+       << "                          corresponding files are absent). See also" << ::std::endl
+       << "                          \033[1m--ignore-unknown\033[0m, \033[1m--repositories-file\033[0m, and" << ::std::endl
+       << "                          \033[1m--packages-file\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--ignore-unknown\033[0m          Ignore unknown manifest entries. Note that this" << ::std::endl
+       << "                          option also ignores the version constraints in the" << ::std::endl
+       << "                          special toolchain build-time dependencies. This" << ::std::endl
+       << "                          option is implied if \033[1m--manifest\033[0m is not specified." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--deep\033[0m                    Verify the presence of the required *-build\033[0m" << ::std::endl
+       << "                          values/files and the validity of files referenced by" << ::std::endl
+       << "                          the \033[1m*-file\033[0m manifest values." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--repositories-file\033[0m \033[4mpath\033[0m  If \033[1m--manifest\033[0m is specified, then save the" << ::std::endl
+       << "                          repositories manifest to the specified file instead" << ::std::endl
+       << "                          of dumping it to \033[1mstdout\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--packages-file\033[0m \033[4mpath\033[0m      If \033[1m--manifest\033[0m is specified, then save the packages" << ::std::endl
+       << "                          manifest to the specified file instead of dumping it" << ::std::endl
+       << "                          to \033[1mstdout\033[0m." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--type\033[0m \033[4mtype\033[0m               Specify the repository type with valid values being" << ::std::endl
+       << "                          \033[1mpkg\033[0m, \033[1mdir\033[0m, and \033[1mgit\033[0m. Refer to \033[1mbpkg-rep-add(1)\033[0m for" << ::std::endl
+       << "                          details." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--directory\033[0m|\033[1m-d\033[0m \033[4mdir\033[0m        Use configuration in \033[4mdir\033[0m for the trusted certificate" << ::std::endl
+       << "                          database." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // common_options base
+    //
+    p = ::bpkg::common_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rep_info_options&, ::bpkg::cli::scanner&)>
+  _cli_rep_info_options_map;
+
+  static _cli_rep_info_options_map _cli_rep_info_options_map_;
+
+  struct _cli_rep_info_options_map_init
+  {
+    _cli_rep_info_options_map_init ()
+    {
+      _cli_rep_info_options_map_["--name"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::name_ >;
+      _cli_rep_info_options_map_["-n"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::name_ >;
+      _cli_rep_info_options_map_["--cert-fingerprint"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::cert_fingerprint_ >;
+      _cli_rep_info_options_map_["--cert-name"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::cert_name_ >;
+      _cli_rep_info_options_map_["--cert-organization"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::cert_organization_ >;
+      _cli_rep_info_options_map_["--cert-email"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::cert_email_ >;
+      _cli_rep_info_options_map_["--repositories"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::repositories_ >;
+      _cli_rep_info_options_map_["-r"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::repositories_ >;
+      _cli_rep_info_options_map_["--packages"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::packages_ >;
+      _cli_rep_info_options_map_["-p"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::packages_ >;
+      _cli_rep_info_options_map_["--manifest"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::manifest_ >;
+      _cli_rep_info_options_map_["--ignore-unknown"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::ignore_unknown_ >;
+      _cli_rep_info_options_map_["--deep"] =
+      &::bpkg::cli::thunk< rep_info_options, &rep_info_options::deep_ >;
+      _cli_rep_info_options_map_["--repositories-file"] =
+      &::bpkg::cli::thunk< rep_info_options, path, &rep_info_options::repositories_file_,
+        &rep_info_options::repositories_file_specified_ >;
+      _cli_rep_info_options_map_["--packages-file"] =
+      &::bpkg::cli::thunk< rep_info_options, path, &rep_info_options::packages_file_,
+        &rep_info_options::packages_file_specified_ >;
+      _cli_rep_info_options_map_["--type"] =
+      &::bpkg::cli::thunk< rep_info_options, repository_type, &rep_info_options::type_,
+        &rep_info_options::type_specified_ >;
+      _cli_rep_info_options_map_["--directory"] =
+      &::bpkg::cli::thunk< rep_info_options, string, &rep_info_options::directory_,
+        &rep_info_options::directory_specified_ >;
+      _cli_rep_info_options_map_["-d"] =
+      &::bpkg::cli::thunk< rep_info_options, string, &rep_info_options::directory_,
+        &rep_info_options::directory_specified_ >;
+    }
+  };
+
+  static _cli_rep_info_options_map_init _cli_rep_info_options_map_init_;
+
+  bool rep_info_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_rep_info_options_map::const_iterator i (_cli_rep_info_options_map_.find (o));
+
+    if (i != _cli_rep_info_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // common_options base
+    //
+    if (::bpkg::common_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool rep_info_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_info_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg rep-info\033[0m [\033[4moptions\033[0m] \033[4mrep-loc\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mrep-info\033[0m command prints various information about the specified repository." << ::std::endl
+       << "By default it print the repository's name and location as the first line. If" << ::std::endl
+       << "the repository is signed, the certificate information (name/organization/email)" << ::std::endl
+       << "is printed as the next line followed by the certificate fingerprint. Then comes" << ::std::endl
+       << "the list of complement and prerequisite repositories followed by the list of" << ::std::endl
+       << "available packages." << ::std::endl
+       << ::std::endl
+       << "This default format can be altered in various ways using options listed below." << ::std::endl
+       << "Note also that the information is written to \033[1mstdout\033[0m, not \033[1mstderr\033[0m." << ::std::endl
+       << ::std::endl
+       << "If the current working directory contains a \033[1mbpkg\033[0m configuration, then \033[1mrep-info\033[0m" << ::std::endl
+       << "will use its certificate database for the repository authentication. That is," << ::std::endl
+       << "it will trust the repository's certificate if it is already trusted by the" << ::std::endl
+       << "configuration. Otherwise it will add the certificate to the configuration if" << ::std::endl
+       << "you confirm it is trusted. You can specify an alternative configuration" << ::std::endl
+       << "directory with the \033[1m--directory|-d\033[0m option. To disable using the configuration in" << ::std::endl
+       << "the current working directory pass this option with an empty path." << ::std::endl;
+
+    p = ::bpkg::rep_info_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "If the \033[1mrep-info\033[0m command uses an existing bpkg\033[0m configuration, then the start" << ::std::endl
+       << "directory is the configuration directory. Otherwise, only the predefined" << ::std::endl
+       << "directories (home, system, etc) are searched. The following options files are" << ::std::endl
+       << "searched for in each directory and, if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-rep-info.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mrep-info\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/rep-info-options.hxx b/bpkg/rep-info-options.hxx
new file mode 100644
index 0000000..8e040da
--- /dev/null
+++ b/bpkg/rep-info-options.hxx
@@ -0,0 +1,183 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REP_INFO_OPTIONS_HXX
+#define BPKG_REP_INFO_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <libbpkg/manifest.hxx>
+
+#include <bpkg/common-options.hxx>
+
+namespace bpkg
+{
+  class rep_info_options: public ::bpkg::common_options
+  {
+    public:
+    rep_info_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const rep_info_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    name () const;
+
+    const bool&
+    cert_fingerprint () const;
+
+    const bool&
+    cert_name () const;
+
+    const bool&
+    cert_organization () const;
+
+    const bool&
+    cert_email () const;
+
+    const bool&
+    repositories () const;
+
+    const bool&
+    packages () const;
+
+    const bool&
+    manifest () const;
+
+    const bool&
+    ignore_unknown () const;
+
+    const bool&
+    deep () const;
+
+    const path&
+    repositories_file () const;
+
+    bool
+    repositories_file_specified () const;
+
+    const path&
+    packages_file () const;
+
+    bool
+    packages_file_specified () const;
+
+    const repository_type&
+    type () const;
+
+    bool
+    type_specified () const;
+
+    const string&
+    directory () const;
+
+    bool
+    directory_specified () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool name_;
+    bool cert_fingerprint_;
+    bool cert_name_;
+    bool cert_organization_;
+    bool cert_email_;
+    bool repositories_;
+    bool packages_;
+    bool manifest_;
+    bool ignore_unknown_;
+    bool deep_;
+    path repositories_file_;
+    bool repositories_file_specified_;
+    path packages_file_;
+    bool packages_file_specified_;
+    repository_type type_;
+    bool type_specified_;
+    string directory_;
+    bool directory_specified_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_info_usage (::std::ostream&,
+                             ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/rep-info-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REP_INFO_OPTIONS_HXX
diff --git a/bpkg/rep-info-options.ixx b/bpkg/rep-info-options.ixx
new file mode 100644
index 0000000..7aa219f
--- /dev/null
+++ b/bpkg/rep-info-options.ixx
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // rep_info_options
+  //
+
+  inline const bool& rep_info_options::
+  name () const
+  {
+    return this->name_;
+  }
+
+  inline const bool& rep_info_options::
+  cert_fingerprint () const
+  {
+    return this->cert_fingerprint_;
+  }
+
+  inline const bool& rep_info_options::
+  cert_name () const
+  {
+    return this->cert_name_;
+  }
+
+  inline const bool& rep_info_options::
+  cert_organization () const
+  {
+    return this->cert_organization_;
+  }
+
+  inline const bool& rep_info_options::
+  cert_email () const
+  {
+    return this->cert_email_;
+  }
+
+  inline const bool& rep_info_options::
+  repositories () const
+  {
+    return this->repositories_;
+  }
+
+  inline const bool& rep_info_options::
+  packages () const
+  {
+    return this->packages_;
+  }
+
+  inline const bool& rep_info_options::
+  manifest () const
+  {
+    return this->manifest_;
+  }
+
+  inline const bool& rep_info_options::
+  ignore_unknown () const
+  {
+    return this->ignore_unknown_;
+  }
+
+  inline const bool& rep_info_options::
+  deep () const
+  {
+    return this->deep_;
+  }
+
+  inline const path& rep_info_options::
+  repositories_file () const
+  {
+    return this->repositories_file_;
+  }
+
+  inline bool rep_info_options::
+  repositories_file_specified () const
+  {
+    return this->repositories_file_specified_;
+  }
+
+  inline const path& rep_info_options::
+  packages_file () const
+  {
+    return this->packages_file_;
+  }
+
+  inline bool rep_info_options::
+  packages_file_specified () const
+  {
+    return this->packages_file_specified_;
+  }
+
+  inline const repository_type& rep_info_options::
+  type () const
+  {
+    return this->type_;
+  }
+
+  inline bool rep_info_options::
+  type_specified () const
+  {
+    return this->type_specified_;
+  }
+
+  inline const string& rep_info_options::
+  directory () const
+  {
+    return this->directory_;
+  }
+
+  inline bool rep_info_options::
+  directory_specified () const
+  {
+    return this->directory_specified_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/rep-list-options.cxx b/bpkg/rep-list-options.cxx
new file mode 100644
index 0000000..c1f456c
--- /dev/null
+++ b/bpkg/rep-list-options.cxx
@@ -0,0 +1,701 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/rep-list-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // rep_list_options
+  //
+
+  rep_list_options::
+  rep_list_options ()
+  : complements_ (),
+    prerequisites_ ()
+  {
+  }
+
+  bool rep_list_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_list_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_list_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_list_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_list_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void rep_list_options::
+  merge (const rep_list_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.complements_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->complements_, a.complements_);
+    }
+
+    if (a.prerequisites_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->prerequisites_, a.prerequisites_);
+    }
+  }
+
+  ::bpkg::cli::usage_para rep_list_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mREP-LIST OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--complements\033[0m|\033[1m-c\033[0m          List complement repositories." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--prerequisites\033[0m|\033[1m-p\033[0m        List prerequisite repositories." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rep_list_options&, ::bpkg::cli::scanner&)>
+  _cli_rep_list_options_map;
+
+  static _cli_rep_list_options_map _cli_rep_list_options_map_;
+
+  struct _cli_rep_list_options_map_init
+  {
+    _cli_rep_list_options_map_init ()
+    {
+      _cli_rep_list_options_map_["--complements"] =
+      &::bpkg::cli::thunk< rep_list_options, &rep_list_options::complements_ >;
+      _cli_rep_list_options_map_["-c"] =
+      &::bpkg::cli::thunk< rep_list_options, &rep_list_options::complements_ >;
+      _cli_rep_list_options_map_["--prerequisites"] =
+      &::bpkg::cli::thunk< rep_list_options, &rep_list_options::prerequisites_ >;
+      _cli_rep_list_options_map_["-p"] =
+      &::bpkg::cli::thunk< rep_list_options, &rep_list_options::prerequisites_ >;
+    }
+  };
+
+  static _cli_rep_list_options_map_init _cli_rep_list_options_map_init_;
+
+  bool rep_list_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_rep_list_options_map::const_iterator i (_cli_rep_list_options_map_.find (o));
+
+    if (i != _cli_rep_list_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool rep_list_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_list_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg rep-list\033[0m|\033[1mlist\033[0m [\033[4moptions\033[0m]\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mrep-list\033[0m command lists the repositories in the configuration." << ::std::endl
+       << ::std::endl
+       << "For each repository a line containing the repository name and location is" << ::std::endl
+       << "printed to \033[1mstdout\033[0m. If the \033[1m--complements|-c\033[0m and/or \033[1m--prerequisites|-p\033[0m options" << ::std::endl
+       << "are specified, then it is followed by the list of complement and/or" << ::std::endl
+       << "prerequisite repositories, recursively." << ::std::endl;
+
+    p = ::bpkg::rep_list_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mrep-list\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-rep-list.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mrep-list\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/rep-list-options.hxx b/bpkg/rep-list-options.hxx
new file mode 100644
index 0000000..a736975
--- /dev/null
+++ b/bpkg/rep-list-options.hxx
@@ -0,0 +1,119 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REP_LIST_OPTIONS_HXX
+#define BPKG_REP_LIST_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <libbpkg/manifest.hxx>
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class rep_list_options: public ::bpkg::configuration_options
+  {
+    public:
+    rep_list_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const rep_list_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    complements () const;
+
+    const bool&
+    prerequisites () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool complements_;
+    bool prerequisites_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_list_usage (::std::ostream&,
+                             ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/rep-list-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REP_LIST_OPTIONS_HXX
diff --git a/bpkg/rep-list-options.ixx b/bpkg/rep-list-options.ixx
new file mode 100644
index 0000000..babc7a0
--- /dev/null
+++ b/bpkg/rep-list-options.ixx
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // rep_list_options
+  //
+
+  inline const bool& rep_list_options::
+  complements () const
+  {
+    return this->complements_;
+  }
+
+  inline const bool& rep_list_options::
+  prerequisites () const
+  {
+    return this->prerequisites_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/rep-remove-options.cxx b/bpkg/rep-remove-options.cxx
new file mode 100644
index 0000000..ffe44be
--- /dev/null
+++ b/bpkg/rep-remove-options.cxx
@@ -0,0 +1,704 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/rep-remove-options.hxx>
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <utility>
+#include <ostream>
+#include <sstream>
+#include <cstring>
+
+namespace bpkg
+{
+  namespace cli
+  {
+    template <typename X>
+    struct parser
+    {
+      static void
+      parse (X& x, bool& xs, scanner& s)
+      {
+        using namespace std;
+
+        const char* o (s.next ());
+        if (s.more ())
+        {
+          string v (s.next ());
+          istringstream is (v);
+          if (!(is >> x && is.peek () == istringstream::traits_type::eof ()))
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (X& b, const X& a)
+      {
+        b = a;
+      }
+    };
+
+    template <>
+    struct parser<bool>
+    {
+      static void
+      parse (bool& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          const char* v (s.next ());
+
+          if (std::strcmp (v, "1")    == 0 ||
+              std::strcmp (v, "true") == 0 ||
+              std::strcmp (v, "TRUE") == 0 ||
+              std::strcmp (v, "True") == 0)
+            x = true;
+          else if (std::strcmp (v, "0")     == 0 ||
+                   std::strcmp (v, "false") == 0 ||
+                   std::strcmp (v, "FALSE") == 0 ||
+                   std::strcmp (v, "False") == 0)
+            x = false;
+          else
+            throw invalid_value (o, v);
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (bool& b, const bool&)
+      {
+        b = true;
+      }
+    };
+
+    template <>
+    struct parser<std::string>
+    {
+      static void
+      parse (std::string& x, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+          x = s.next ();
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::string& b, const std::string& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::pair<X, std::size_t> >
+    {
+      static void
+      parse (std::pair<X, std::size_t>& x, bool& xs, scanner& s)
+      {
+        x.second = s.position ();
+        parser<X>::parse (x.first, xs, s);
+      }
+
+      static void
+      merge (std::pair<X, std::size_t>& b, const std::pair<X, std::size_t>& a)
+      {
+        b = a;
+      }
+    };
+
+    template <typename X>
+    struct parser<std::vector<X> >
+    {
+      static void
+      parse (std::vector<X>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.push_back (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::vector<X>& b, const std::vector<X>& a)
+      {
+        b.insert (b.end (), a.begin (), a.end ());
+      }
+    };
+
+    template <typename X, typename C>
+    struct parser<std::set<X, C> >
+    {
+      static void
+      parse (std::set<X, C>& c, bool& xs, scanner& s)
+      {
+        X x;
+        bool dummy;
+        parser<X>::parse (x, dummy, s);
+        c.insert (x);
+        xs = true;
+      }
+
+      static void
+      merge (std::set<X, C>& b, const std::set<X, C>& a)
+      {
+        b.insert (a.begin (), a.end ());
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::map<K, V, C> >
+    {
+      static void
+      parse (std::map<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m[k] = v;
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::map<K, V, C>& b, const std::map<K, V, C>& a)
+      {
+        for (typename std::map<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b[i->first] = i->second;
+      }
+    };
+
+    template <typename K, typename V, typename C>
+    struct parser<std::multimap<K, V, C> >
+    {
+      static void
+      parse (std::multimap<K, V, C>& m, bool& xs, scanner& s)
+      {
+        const char* o (s.next ());
+
+        if (s.more ())
+        {
+          std::size_t pos (s.position ());
+          std::string ov (s.next ());
+          std::string::size_type p = ov.find ('=');
+
+          K k = K ();
+          V v = V ();
+          std::string kstr (ov, 0, p);
+          std::string vstr (ov, (p != std::string::npos ? p + 1 : ov.size ()));
+
+          int ac (2);
+          char* av[] =
+          {
+            const_cast<char*> (o),
+            0
+          };
+
+          bool dummy;
+          if (!kstr.empty ())
+          {
+            av[1] = const_cast<char*> (kstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<K>::parse (k, dummy, s);
+          }
+
+          if (!vstr.empty ())
+          {
+            av[1] = const_cast<char*> (vstr.c_str ());
+            argv_scanner s (0, ac, av, false, pos);
+            parser<V>::parse (v, dummy, s);
+          }
+
+          m.insert (typename std::multimap<K, V, C>::value_type (k, v));
+        }
+        else
+          throw missing_value (o);
+
+        xs = true;
+      }
+
+      static void
+      merge (std::multimap<K, V, C>& b, const std::multimap<K, V, C>& a)
+      {
+        for (typename std::multimap<K, V, C>::const_iterator i (a.begin ()); 
+             i != a.end (); 
+             ++i)
+          b.insert (typename std::multimap<K, V, C>::value_type (i->first,
+                                                                 i->second));
+      }
+    };
+
+    template <typename X, typename T, T X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, s);
+    }
+
+    template <typename X, bool X::*M>
+    void
+    thunk (X& x, scanner& s)
+    {
+      s.next ();
+      x.*M = true;
+    }
+
+    template <typename X, typename T, T X::*M, bool X::*S>
+    void
+    thunk (X& x, scanner& s)
+    {
+      parser<T>::parse (x.*M, x.*S, s);
+    }
+  }
+}
+
+#include <map>
+
+namespace bpkg
+{
+  // rep_remove_options
+  //
+
+  rep_remove_options::
+  rep_remove_options ()
+  : all_ (),
+    clean_ ()
+  {
+  }
+
+  bool rep_remove_options::
+  parse (int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_remove_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  bool rep_remove_options::
+  parse (int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_remove_options::
+  parse (int start,
+         int& argc,
+         char** argv,
+         int& end,
+         bool erase,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    ::bpkg::cli::argv_scanner s (start, argc, argv, erase);
+    bool r = _parse (s, opt, arg);
+    end = s.end ();
+    return r;
+  }
+
+  bool rep_remove_options::
+  parse (::bpkg::cli::scanner& s,
+         ::bpkg::cli::unknown_mode opt,
+         ::bpkg::cli::unknown_mode arg)
+  {
+    bool r = _parse (s, opt, arg);
+    return r;
+  }
+
+  void rep_remove_options::
+  merge (const rep_remove_options& a)
+  {
+    CLI_POTENTIALLY_UNUSED (a);
+
+    // configuration_options base
+    //
+    ::bpkg::configuration_options::merge (a);
+
+    if (a.all_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->all_, a.all_);
+    }
+
+    if (a.clean_)
+    {
+      ::bpkg::cli::parser< bool>::merge (
+        this->clean_, a.clean_);
+    }
+  }
+
+  ::bpkg::cli::usage_para rep_remove_options::
+  print_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mREP-REMOVE OPTIONS\033[0m" << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--all\033[0m|\033[1m-a\033[0m                  Remove all the repositories." << ::std::endl;
+
+    os << std::endl
+       << "\033[1m--clean\033[0m                   Clean the repository state." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::option;
+
+    // configuration_options base
+    //
+    p = ::bpkg::configuration_options::print_usage (os, p);
+
+    return p;
+  }
+
+  typedef
+  std::map<std::string, void (*) (rep_remove_options&, ::bpkg::cli::scanner&)>
+  _cli_rep_remove_options_map;
+
+  static _cli_rep_remove_options_map _cli_rep_remove_options_map_;
+
+  struct _cli_rep_remove_options_map_init
+  {
+    _cli_rep_remove_options_map_init ()
+    {
+      _cli_rep_remove_options_map_["--all"] =
+      &::bpkg::cli::thunk< rep_remove_options, &rep_remove_options::all_ >;
+      _cli_rep_remove_options_map_["-a"] =
+      &::bpkg::cli::thunk< rep_remove_options, &rep_remove_options::all_ >;
+      _cli_rep_remove_options_map_["--clean"] =
+      &::bpkg::cli::thunk< rep_remove_options, &rep_remove_options::clean_ >;
+    }
+  };
+
+  static _cli_rep_remove_options_map_init _cli_rep_remove_options_map_init_;
+
+  bool rep_remove_options::
+  _parse (const char* o, ::bpkg::cli::scanner& s)
+  {
+    _cli_rep_remove_options_map::const_iterator i (_cli_rep_remove_options_map_.find (o));
+
+    if (i != _cli_rep_remove_options_map_.end ())
+    {
+      (*(i->second)) (*this, s);
+      return true;
+    }
+
+    // configuration_options base
+    //
+    if (::bpkg::configuration_options::_parse (o, s))
+      return true;
+
+    return false;
+  }
+
+  bool rep_remove_options::
+  _parse (::bpkg::cli::scanner& s,
+          ::bpkg::cli::unknown_mode opt_mode,
+          ::bpkg::cli::unknown_mode arg_mode)
+  {
+    // Can't skip combined flags (--no-combined-flags).
+    //
+    assert (opt_mode != ::bpkg::cli::unknown_mode::skip);
+
+    bool r = false;
+    bool opt = true;
+
+    while (s.more ())
+    {
+      const char* o = s.peek ();
+
+      if (std::strcmp (o, "--") == 0)
+      {
+        opt = false;
+      }
+
+      if (opt)
+      {
+        if (_parse (o, s))
+        {
+          r = true;
+          continue;
+        }
+
+        if (std::strncmp (o, "-", 1) == 0 && o[1] != '\0')
+        {
+          // Handle combined option values.
+          //
+          std::string co;
+          if (const char* v = std::strchr (o, '='))
+          {
+            co.assign (o, 0, v - o);
+            ++v;
+
+            int ac (2);
+            char* av[] =
+            {
+              const_cast<char*> (co.c_str ()),
+              const_cast<char*> (v)
+            };
+
+            ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+            if (_parse (co.c_str (), ns))
+            {
+              // Parsed the option but not its value?
+              //
+              if (ns.end () != 2)
+                throw ::bpkg::cli::invalid_value (co, v);
+
+              s.next ();
+              r = true;
+              continue;
+            }
+            else
+            {
+              // Set the unknown option and fall through.
+              //
+              o = co.c_str ();
+            }
+          }
+
+          // Handle combined flags.
+          //
+          char cf[3];
+          {
+            const char* p = o + 1;
+            for (; *p != '\0'; ++p)
+            {
+              if (!((*p >= 'a' && *p <= 'z') ||
+                    (*p >= 'A' && *p <= 'Z') ||
+                    (*p >= '0' && *p <= '9')))
+                break;
+            }
+
+            if (*p == '\0')
+            {
+              for (p = o + 1; *p != '\0'; ++p)
+              {
+                std::strcpy (cf, "-");
+                cf[1] = *p;
+                cf[2] = '\0';
+
+                int ac (1);
+                char* av[] =
+                {
+                  cf
+                };
+
+                ::bpkg::cli::argv_scanner ns (0, ac, av);
+
+                if (!_parse (cf, ns))
+                  break;
+              }
+
+              if (*p == '\0')
+              {
+                // All handled.
+                //
+                s.next ();
+                r = true;
+                continue;
+              }
+              else
+              {
+                // Set the unknown option and fall through.
+                //
+                o = cf;
+              }
+            }
+          }
+
+          switch (opt_mode)
+          {
+            case ::bpkg::cli::unknown_mode::skip:
+            {
+              s.skip ();
+              r = true;
+              continue;
+            }
+            case ::bpkg::cli::unknown_mode::stop:
+            {
+              break;
+            }
+            case ::bpkg::cli::unknown_mode::fail:
+            {
+              throw ::bpkg::cli::unknown_option (o);
+            }
+          }
+
+          break;
+        }
+      }
+
+      switch (arg_mode)
+      {
+        case ::bpkg::cli::unknown_mode::skip:
+        {
+          s.skip ();
+          r = true;
+          continue;
+        }
+        case ::bpkg::cli::unknown_mode::stop:
+        {
+          break;
+        }
+        case ::bpkg::cli::unknown_mode::fail:
+        {
+          throw ::bpkg::cli::unknown_argument (o);
+        }
+      }
+
+      break;
+    }
+
+    return r;
+  }
+}
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_remove_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg rep-remove\033[0m|\033[1mremove\033[0m [\033[4moptions\033[0m] (\033[4mrep-name\033[0m|\033[4mrep-loc\033[0m)..." << ::std::endl
+       << "\033[1mbpkg rep-remove\033[0m|\033[1mremove\033[0m [\033[4moptions\033[0m] \033[1m--all\033[0m|\033[1m-a\033[0m" << ::std::endl
+       << "\033[1mbpkg rep-remove\033[0m|\033[1mremove\033[0m [\033[4moptions\033[0m] \033[1m--clean\033[0m\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The \033[1mrep-remove\033[0m command removes the specified package repositories from the" << ::std::endl
+       << "configuration. The repository to remove can be specified either as a repository" << ::std::endl
+       << "name or as a repository location (URL or a directory path)." << ::std::endl
+       << ::std::endl
+       << "Alternatively, the \033[1m--all|-a\033[0m option can be used to remove all the repositories" << ::std::endl
+       << "that were previously added (\033[1mbpkg-rep-add(1)\033[0m) to the configuration." << ::std::endl
+       << ::std::endl
+       << "Finally, the \033[1m--clean\033[0m option can be used to revert the repositories to the clean" << ::std::endl
+       << "state, as if they were added but never fetched." << ::std::endl;
+
+    p = ::bpkg::rep_remove_options::print_usage (os, ::bpkg::cli::usage_para::text);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDEFAULT OPTIONS FILES\033[0m" << ::std::endl
+       << ::std::endl
+       << "See \033[1mbpkg-default-options-files(1)\033[0m for an overview of the default options files." << ::std::endl
+       << "For the \033[1mpkg-rep-remove\033[0m command the search start directory is the configuration" << ::std::endl
+       << "directory. The following options files are searched for in each directory and," << ::std::endl
+       << "if found, loaded in the order listed:" << ::std::endl
+       << ::std::endl
+       << "bpkg.options" << ::std::endl
+       << "bpkg-rep-remove.options" << ::std::endl
+       << ::std::endl
+       << "The following \033[1mrep-remove\033[0m command options cannot be specified in the default" << ::std::endl
+       << "options files:" << ::std::endl
+       << ::std::endl
+       << "--directory|-d" << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/rep-remove-options.hxx b/bpkg/rep-remove-options.hxx
new file mode 100644
index 0000000..eedbe27
--- /dev/null
+++ b/bpkg/rep-remove-options.hxx
@@ -0,0 +1,119 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REP_REMOVE_OPTIONS_HXX
+#define BPKG_REP_REMOVE_OPTIONS_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <libbpkg/manifest.hxx>
+
+#include <bpkg/configuration-options.hxx>
+
+namespace bpkg
+{
+  class rep_remove_options: public ::bpkg::configuration_options
+  {
+    public:
+    rep_remove_options ();
+
+    // Return true if anything has been parsed.
+    //
+    bool
+    parse (int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (int start,
+           int& argc,
+           char** argv,
+           int& end,
+           bool erase = false,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    bool
+    parse (::bpkg::cli::scanner&,
+           ::bpkg::cli::unknown_mode option = ::bpkg::cli::unknown_mode::fail,
+           ::bpkg::cli::unknown_mode argument = ::bpkg::cli::unknown_mode::stop);
+
+    // Merge options from the specified instance appending/overriding
+    // them as if they appeared after options in this instance.
+    //
+    void
+    merge (const rep_remove_options&);
+
+    // Option accessors.
+    //
+    const bool&
+    all () const;
+
+    const bool&
+    clean () const;
+
+    // Print usage information.
+    //
+    static ::bpkg::cli::usage_para
+    print_usage (::std::ostream&,
+                 ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+
+    // Implementation details.
+    //
+    protected:
+    bool
+    _parse (const char*, ::bpkg::cli::scanner&);
+
+    private:
+    bool
+    _parse (::bpkg::cli::scanner&,
+            ::bpkg::cli::unknown_mode option,
+            ::bpkg::cli::unknown_mode argument);
+
+    public:
+    bool all_;
+    bool clean_;
+  };
+}
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_rep_remove_usage (::std::ostream&,
+                               ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+#include <bpkg/rep-remove-options.ixx>
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REP_REMOVE_OPTIONS_HXX
diff --git a/bpkg/rep-remove-options.ixx b/bpkg/rep-remove-options.ixx
new file mode 100644
index 0000000..b8ec8ba
--- /dev/null
+++ b/bpkg/rep-remove-options.ixx
@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+namespace bpkg
+{
+  // rep_remove_options
+  //
+
+  inline const bool& rep_remove_options::
+  all () const
+  {
+    return this->all_;
+  }
+
+  inline const bool& rep_remove_options::
+  clean () const
+  {
+    return this->clean_;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
diff --git a/bpkg/repository-signing.cxx b/bpkg/repository-signing.cxx
new file mode 100644
index 0000000..66366cb
--- /dev/null
+++ b/bpkg/repository-signing.cxx
@@ -0,0 +1,205 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/repository-signing.hxx>
+
+#include <map>
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_repository_signing_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mSYNOPSIS\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg rep-create --key\033[0m ...\033[0m" << ::std::endl
+       << ::std::endl
+       << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "The purpose of signing a repository is to prevent tampering with packages" << ::std::endl
+       << "either during transmission or on the repository \033[4mhost machine\033[0m. Ideally, you" << ::std::endl
+       << "would generate and sign the repository manifests on a separate \033[4mbuild machine\033[0m" << ::std::endl
+       << "that is behind a firewall. This way, if (or, really, when) your host machine is" << ::std::endl
+       << "compromised, it will be difficult for an attacker to compromise the repository" << ::std::endl
+       << "packages without being noticed. Since the repository key is kept on the build" << ::std::endl
+       << "machine (or, better yet, on a \033[4mone-way\033[0m PIV/PKCS#11 device; see below) they will" << ::std::endl
+       << "not be able to re-sign the modified repository." << ::std::endl
+       << ::std::endl
+       << "\033[1mbpkg\033[0m uses X.509 public key cryptography for repository signing. Currently, only" << ::std::endl
+       << "the explicit \033[4mfirst use\033[0m certificate authentication is implemented.  That is, for" << ::std::endl
+       << "an unknown (to this \033[1mbpkg\033[0m configuration) repository certificate its subject" << ::std::endl
+       << "information and fingerprint are presented to the user. If the user confirms the" << ::std::endl
+       << "authenticity of the certificate, then it is added to the configuration and any" << ::std::endl
+       << "repository that in the future presents this certificate is trusted without" << ::std::endl
+       << "further confirmations, provided its name matches the certificate's subject (see" << ::std::endl
+       << "below). In the future a certificate authority (CA)-based model may be added." << ::std::endl
+       << ::std::endl
+       << "The rest of this guide shows how to create a key/certificate pair for \033[1mpkg\033[0m" << ::std::endl
+       << "repository signing and use it to sign a repository. At the end it also briefly" << ::std::endl
+       << "explains how to store the private key on a PIV/PKCS#11 device using Yubikey 4" << ::std::endl
+       << "as an example." << ::std::endl
+       << ::std::endl
+       << "1. Generate Private Key" << ::std::endl
+       << ::std::endl
+       << "    The first step is to generate the private key:" << ::std::endl
+       << ::std::endl
+       << "    $ openssl genrsa -aes256 2048 >key.pem" << ::std::endl
+       << ::std::endl
+       << "    If you would like to generate a key without password protection (not a good" << ::std::endl
+       << "    idea except for testing), leave the \033[1m-aes256\033[0m option out. You may also need" << ::std::endl
+       << "    to add \033[1m-nodes\033[0m depending on your \033[1mopenssl(1)\033[0m configuration." << ::std::endl
+       << ::std::endl
+       << "2. Generate Certificate" << ::std::endl
+       << ::std::endl
+       << "    Next create the certificate configuration file by saving the following into" << ::std::endl
+       << "    \033[1mcert.conf\033[0m. You may want to keep it around in case you need to renew an" << ::std::endl
+       << "    expired certificate, etc." << ::std::endl
+       << ::std::endl
+       << "    name  = example.com" << ::std::endl
+       << "    org   = Example, Inc" << ::std::endl
+       << "    email = admin@example.com" << ::std::endl
+       << ::std::endl
+       << "    [req]" << ::std::endl
+       << "    distinguished_name = req_distinguished_name" << ::std::endl
+       << "    x509_extensions    = v3_req" << ::std::endl
+       << "    prompt             = no" << ::std::endl
+       << "    utf8               = yes" << ::std::endl
+       << ::std::endl
+       << "    [req_distinguished_name]" << ::std::endl
+       << "    O  = $org" << ::std::endl
+       << "    CN = name:$name" << ::std::endl
+       << ::std::endl
+       << "    [v3_req]" << ::std::endl
+       << "    keyUsage         = critical,digitalSignature" << ::std::endl
+       << "    extendedKeyUsage = critical,codeSigning" << ::std::endl
+       << "    subjectAltName   = email:$email" << ::std::endl
+       << ::std::endl
+       << "    Adjust the first three lines to match your details. If the repository is" << ::std::endl
+       << "    hosted by an organization, use the organization's name for \033[1morg\033[0m. If you host" << ::std::endl
+       << "    it as an individual, put your full, real name there. Using any kind of" << ::std::endl
+       << "    aliases or nicknames is a bad idea (except, again, for testing). Remember," << ::std::endl
+       << "    users of your repository will be presented with this information and if" << ::std::endl
+       << "    they see it was signed by someone named SmellySnook, they will unlikely" << ::std::endl
+       << "    trust it. Also use a working email address in case users need to contact" << ::std::endl
+       << "    you about issues with your certificate. Note that the \033[1mname:\033[0m prefix in the" << ::std::endl
+       << "    \033[1mCN\033[0m value is not a typo." << ::std::endl
+       << ::std::endl
+       << "    The \033[1mname\033[0m field is a canonical repository name prefix with the \033[1mpkg:\033[0m type" << ::std::endl
+       << "    part stripped. Any repository with a canonical name that starts with this" << ::std::endl
+       << "    prefix can be authenticated by this certificate (see the repository" << ::std::endl
+       << "    manifest documentation for more information on canonical names). For" << ::std::endl
+       << "    example, name \033[1mexample.com\033[0m will match any repository hosted on" << ::std::endl
+       << "    \033[1m{,www.,pkg.,bpkg.}example.com\033[0m. While name \033[1mexample.com/math\033[0m will match" << ::std::endl
+       << "    \033[1m{...}example.com/pkg/1/math\033[0m but not \033[1m{...}example.com/pkg/1/misc\033[0m." << ::std::endl
+       << ::std::endl
+       << "    A certificate name can also contain a subdomain wildcard. A wildcard name" << ::std::endl
+       << "    in the \033[1m*.example.com\033[0m form matches any single-level subdomain, for example" << ::std::endl
+       << "    \033[1mfoo.example.com\033[0m but not \033[1mfoo.bar.example.com\033[0m while a wildcard name in the" << ::std::endl
+       << "    \033[1m**.example.com\033[0m form matches any subdomain, including multi-level. The above" << ::std::endl
+       << "    two forms do not match the domain itself (\033[1mexample.com\033[0m in the above" << ::std::endl
+       << "    example). If this is desired, the \033[1m*example.com\033[0m and \033[1m**example.com\033[0m forms" << ::std::endl
+       << "    should be used instead. Note that these forms still only match subdomains." << ::std::endl
+       << "    In other words, they won't match \033[1mfooexample.com\033[0m. Wildcard names are less" << ::std::endl
+       << "    secure and therefore are normally only used for testing and/or internal" << ::std::endl
+       << "    repositories." << ::std::endl
+       << ::std::endl
+       << "    Once the configuration file is ready, generate the certificate:" << ::std::endl
+       << ::std::endl
+       << "    openssl req -x509 -new -sha256 -key key.pem \\" << ::std::endl
+       << "      -config cert.conf -days 730 >cert.pem" << ::std::endl
+       << ::std::endl
+       << "    To verify the certificate information, run:" << ::std::endl
+       << ::std::endl
+       << "    openssl x509 -noout -nameopt RFC2253,sep_multiline \\" << ::std::endl
+       << "      -subject -dates -email <cert.pem" << ::std::endl
+       << ::std::endl
+       << "3. Add Certificate to Repository" << ::std::endl
+       << ::std::endl
+       << "    Add the \033[1mcertificate:\033[0m field for the base repository (\033[1mrole: base\033[0m) in the" << ::std::endl
+       << "    \033[1mrepositories\033[0m manifest file(s):" << ::std::endl
+       << ::std::endl
+       << "    certificate:" << ::std::endl
+       << "    \\" << ::std::endl
+       << "    <cert>" << ::std::endl
+       << "    \\" << ::std::endl
+       << ::std::endl
+       << "    Replace \033[4mcert\033[0m with the entire contents of \033[1mcert.pem\033[0m (including the BEGIN" << ::std::endl
+       << "    CERTIFICATE\033[0m and END CERTIFICATE\033[0m lines). So you will have an entry like" << ::std::endl
+       << "    this:" << ::std::endl
+       << ::std::endl
+       << "    certificate:" << ::std::endl
+       << "    \\" << ::std::endl
+       << "    -----BEGIN CERTIFICATE-----" << ::std::endl
+       << "    MIIDQjCCAiqgAwIBAgIJAIUgsIqSnesGMA0GCSqGSIb3DQEBCwUAMDkxFzAVBgNV" << ::std::endl
+       << "    ." << ::std::endl
+       << "    ." << ::std::endl
+       << "    ." << ::std::endl
+       << "    +NOVBamEvjn58ZcLfWh2oKee7ulIZg==" << ::std::endl
+       << "    -----END CERTIFICATE-----" << ::std::endl
+       << "    \\" << ::std::endl
+       << ::std::endl
+       << "4. Sign Repository" << ::std::endl
+       << ::std::endl
+       << "    When generating the repository manifests with the \033[1mbpkg-rep-create(1)\033[0m" << ::std::endl
+       << "    command, specify the path to \033[1mkey.pem\033[0m with the \033[1m--key\033[0m option:" << ::std::endl
+       << ::std::endl
+       << "    bpkg rep-create --key /path/to/key.pem /path/to/repository" << ::std::endl
+       << ::std::endl
+       << "    You will be prompted for a password to unlock the private key." << ::std::endl
+       << ::std::endl
+       << "5. Using PIV/PKCS#11 Device" << ::std::endl
+       << ::std::endl
+       << "    This optional step shows how to load the private key into Yubikey 4 and" << ::std::endl
+       << "    then use it instead of the private key itself for signing the repository." << ::std::endl
+       << "    Note that you will need OpenSSL 1.0.2 or later for the signing part to" << ::std::endl
+       << "    work." << ::std::endl
+       << ::std::endl
+       << "    First change the Yubikey MKEY, PUK, and PIN if necessary. You should" << ::std::endl
+       << "    definitely do this if it still has the factory defaults. Then import the" << ::std::endl
+       << "    private key and the certificate into Yubikey (replace \033[4mmkey\033[0m with the" << ::std::endl
+       << "    management key):" << ::std::endl
+       << ::std::endl
+       << "    yubico-piv-tool --key=<mkey> -a import-key -s 9c <key.pem" << ::std::endl
+       << "    yubico-piv-tool --key=<mkey> -a import-certificate -s 9c <cert.pem" << ::std::endl
+       << ::std::endl
+       << "    After this you will normally save the certificate/private key onto backup" << ::std::endl
+       << "    media, store it in a secure, offline location, and remove the key from the" << ::std::endl
+       << "    build machine." << ::std::endl
+       << ::std::endl
+       << "    To sign the repository with Yubikey specify the following options instead" << ::std::endl
+       << "    of just \033[1m--key\033[0m as at step 4 (\"SIGN key\"\033[0m is the label for the slot 9c\033[0m private" << ::std::endl
+       << "    key):" << ::std::endl
+       << ::std::endl
+       << "    bpkg rep-create                                                     \\" << ::std::endl
+       << "      --openssl-option pkeyutl:-engine --openssl-option pkeyutl:pkcs11  \\" << ::std::endl
+       << "      --openssl-option pkeyutl:-keyform --openssl-option pkeyutl:engine \\" << ::std::endl
+       << "      --key \"pkcs11:object=SIGN%20key\" /path/to/repository" << ::std::endl
+       << ::std::endl
+       << "    Note that for \033[1mopenssl\033[0m versions prior to \033[1m3.0.0\033[0m \033[1mbpkg\033[0m uses the \033[1mrsautl\033[0m command" << ::std::endl
+       << "    instead of \033[1mpkeyutl\033[0m for the data signing operation." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/repository-signing.hxx b/bpkg/repository-signing.hxx
new file mode 100644
index 0000000..d5338e1
--- /dev/null
+++ b/bpkg/repository-signing.hxx
@@ -0,0 +1,31 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REPOSITORY_SIGNING_HXX
+#define BPKG_REPOSITORY_SIGNING_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_repository_signing_usage (::std::ostream&,
+                                       ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REPOSITORY_SIGNING_HXX
diff --git a/bpkg/repository-types.cxx b/bpkg/repository-types.cxx
new file mode 100644
index 0000000..90efcdd
--- /dev/null
+++ b/bpkg/repository-types.cxx
@@ -0,0 +1,206 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+// Begin prologue.
+//
+#include <bpkg/types-parsers.hxx>
+//
+// End prologue.
+
+#include <bpkg/repository-types.hxx>
+
+#include <map>
+
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_repository_types_usage (::std::ostream& os, ::bpkg::cli::usage_para p)
+  {
+    CLI_POTENTIALLY_UNUSED (os);
+
+    if (p != ::bpkg::cli::usage_para::none)
+      os << ::std::endl;
+
+    os << "\033[1mDESCRIPTION\033[0m" << ::std::endl
+       << ::std::endl
+       << "This help topic describes the repository types recognized by \033[1mbpkg\033[0m, their" << ::std::endl
+       << "structure, and the format of their URLs. Currently three types of repositories" << ::std::endl
+       << "are supported: archive-based \033[1mpkg\033[0m, directory-based \033[1mdir\033[0m, and version" << ::std::endl
+       << "control-based \033[1mgit\033[0m." << ::std::endl
+       << ::std::endl
+       << "The repository location may specify the repository type as part of the URL" << ::std::endl
+       << "scheme component in the \033[4mtype\033[0m\033[1m+\033[0m\033[4mprotocol\033[0m\033[0m form. For example:" << ::std::endl
+       << ::std::endl
+       << "git+https://example.com/foo" << ::std::endl
+       << "dir+file:///tmp/repo" << ::std::endl
+       << ::std::endl
+       << "Note that the explicit specification is only needed when the correct type" << ::std::endl
+       << "cannot be guessed from the URL. See \033[1mbpkg-rep-add(1)\033[0m for details." << ::std::endl
+       << ::std::endl
+       << "\033[1mPKG REPOSITORIES\033[0m" << ::std::endl
+       << ::std::endl
+       << "A \033[1mpkg\033[0m repository is \033[4marchive\033[0m-based. That is, it contains a collection of various" << ::std::endl
+       << "packages/versions as archive files. For more information on the structure of" << ::std::endl
+       << "\033[1mpkg\033[0m repositories refer to The \033[1mbuild2\033[0m Package Manager Manual (bpkg). The \033[1mpkg\033[0m" << ::std::endl
+       << "repository location can be a local directory path or an \033[1mhttp(s)://\033[0m URL." << ::std::endl
+       << ::std::endl
+       << "\033[1mDIR REPOSITORIES\033[0m" << ::std::endl
+       << ::std::endl
+       << "A \033[1mdir\033[0m repository is \033[4mdirectory\033[0m-based. That is, it contains a collection of" << ::std::endl
+       << "various packages as directories but only a single version per package can be" << ::std::endl
+       << "present in such a repository. The \033[1mdir\033[0m repository location can be a local" << ::std::endl
+       << "directory path or a \033[1mfile://\033[0m URL." << ::std::endl
+       << ::std::endl
+       << "A \033[1mdir\033[0m repository is expected to contain either the \033[1mmanifest\033[0m or" << ::std::endl
+       << "\033[1mpackages.manifest\033[0m file in the root directory of the repository. If it only" << ::std::endl
+       << "contains \033[1mmanifest\033[0m, then it is assumed to be a simple, single-package repository" << ::std::endl
+       << "with the \033[1mmanifest\033[0m file being its package manifest. Otherwise, the" << ::std::endl
+       << "\033[1mpackages.manifest\033[0m file should list the locations of available packages as" << ::std::endl
+       << "described in Package List Manifest for \033[1mdir\033[0m Repositories" << ::std::endl
+       << "(bpkg#manifest-package-list-dir)." << ::std::endl
+       << ::std::endl
+       << "A \033[1mdir\033[0m repository may also contain the \033[1mrepositories.manifest\033[0m file in the root" << ::std::endl
+       << "directory of the repository. This file can be used to describe the repository" << ::std::endl
+       << "itself as well as specify its prerequisite and complement repositories. See" << ::std::endl
+       << "Repository List Manifest (bpkg#manifest-repository-list) for details on the" << ::std::endl
+       << "format and semantics of this file." << ::std::endl
+       << ::std::endl
+       << "\033[1mGIT REPOSITORIES\033[0m" << ::std::endl
+       << ::std::endl
+       << "A \033[1mgit\033[0m repository is \033[4mversion control\033[0m-based. That is, it normally contains" << ::std::endl
+       << "multiple versions of the same package (but can also contain several, usually" << ::std::endl
+       << "related, packages in the same repository)." << ::std::endl
+       << ::std::endl
+       << "A \033[1mgit\033[0m repository has the same structure and manifest files as the \033[1mdir\033[0m" << ::std::endl
+       << "repository. See Package List Manifest for \033[1mdir\033[0m Repositories" << ::std::endl
+       << "(bpkg#manifest-package-list-dir) and Repository List Manifest" << ::std::endl
+       << "(bpkg#manifest-repository-list) for details on their format and semantics." << ::std::endl
+       << ::std::endl
+       << "Theoretically, a \033[1mgit\033[0m repository may contain as many package versions as there" << ::std::endl
+       << "are commits. Practically, however, we are normally only interested in a small" << ::std::endl
+       << "subset of them while fetching and processing the necessary information for all" << ::std::endl
+       << "of them could be prohibitively expensive.  As a result, by default, only" << ::std::endl
+       << "advertised tags in the \033[1mrefs/tags/v*\033[0m form where the part after \033[1mv\033[0m is also a valid" << ::std::endl
+       << "standard version (b#module-version) are considered to be sources of useful" << ::std::endl
+       << "package versions. These commits normally correspond to released versions and" << ::std::endl
+       << "are called the \033[4mdefault set\033[0m. Note that only the latest revision of each such" << ::std::endl
+       << "version is considered." << ::std::endl
+       << ::std::endl
+       << "Instead of the default set, it is possible to provide a custom set of available" << ::std::endl
+       << "versions by specifying one or more commit ids and/or references and/or" << ::std::endl
+       << "reference patterns in the repository URL fragment (see \033[1mgit-ls-remote(1)\033[0m for" << ::std::endl
+       << "details on advertised references). For example:" << ::std::endl
+       << ::std::endl
+       << "https://example.com/foo.git#v1.2.3" << ::std::endl
+       << "https://example.com/foo.git#master" << ::std::endl
+       << "https://example.com/foo.git#af234f56" << ::std::endl
+       << "https://example.com/foo.git#tags/releases/*" << ::std::endl
+       << "https://example.com/foo.git#HEAD,tags/v1.*.*,heads/feature-*" << ::std::endl
+       << ::std::endl
+       << "Furthermore, it is possible to expand (or narrow down) the default set using" << ::std::endl
+       << "the special \033[1m##\033[0m fragment notation. For example:" << ::std::endl
+       << ::std::endl
+       << "https://example.com/foo.git##HEAD     - default set plus HEAD" << ::std::endl
+       << "https://example.com/foo.git##heads/*  - default set plus branches" << ::std::endl
+       << "https://example.com/foo.git##-v1.*    - default set minus v1.*" << ::std::endl
+       << ::std::endl
+       << "A \033[1mgit\033[0m repository URL fragment is a comma-separated list of reference filters in" << ::std::endl
+       << "the following form:" << ::std::endl
+       << ::std::endl
+       << "[\033[4mrefname\033[0m][\033[1m@\033[0m\033[4mcommit\033[0m]\033[0m" << ::std::endl
+       << ::std::endl
+       << "Either \033[4mrefname\033[0m, \033[4mcommit\033[0m, or both must be specified. If both are specified then" << ::std::endl
+       << "\033[4mrefname\033[0m is only used to minimize the amount of data fetched and \033[4mcommit\033[0m is" << ::std::endl
+       << "expected to belong to its history. For example:" << ::std::endl
+       << ::std::endl
+       << ".../foo.git#master@48fba3625d65941bb85a39061bcf795d4949c778" << ::std::endl
+       << ::std::endl
+       << "The \033[4mrefname\033[0m part can be an abbreviated commit id or an advertised reference or" << ::std::endl
+       << "reference pattern under \033[1mrefs/\033[0m. While \033[4mcommit\033[0m must be the complete, 40-characters" << ::std::endl
+       << "SHA1 that need not be advertised. For convenience, a 40-characters filter that" << ::std::endl
+       << "consists of only hexadecimal digits is assumed to be \033[4mcommit\033[0m even if not" << ::std::endl
+       << "prefixed with \033[1m@\033[0m. In an unlikely event this produces an incorrect result, the" << ::std::endl
+       << "\033[1m@\033[0m-form with omitted \033[4mcommit\033[0m can be used. For example:" << ::std::endl
+       << ::std::endl
+       << ".../foo.git#48fba3625d65941bb85a39061bcf795d4949c778   (commit id)" << ::std::endl
+       << ".../foo.git#deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@  (reference)" << ::std::endl
+       << ::std::endl
+       << "The \033[4mrefname\033[0m part can use the \033[1m*\033[0m and \033[1m?\033[0m wildcard pattern characters with the" << ::std::endl
+       << "standard semantics as well as the \033[1m**\033[0m character sequence which matches in" << ::std::endl
+       << "subdirectories, recursively. For example:" << ::std::endl
+       << ::std::endl
+       << ".../foo.git#tags/v*    - tags/v1.2.3 but not tags/old/v0.1.0" << ::std::endl
+       << ".../foo.git#tags/v**   - tags/v1.2.3 and tags/old/v0.1.0" << ::std::endl
+       << ::std::endl
+       << "A relative \033[4mrefname\033[0m is searched for in \033[1mrefs/\033[0m, \033[1mrefs/tags/\033[0m, and \033[1mrefs/heads/\033[0m as" << ::std::endl
+       << "well as among symbolic references like \033[1mHEAD\033[0m. To anchor it to \033[1mrefs/\033[0m make it" << ::std::endl
+       << "absolute, for example:" << ::std::endl
+       << ::std::endl
+       << ".../foo.git#tags/v*   - refs/tags/v1.2.3 but also refs/heads/tags/voo" << ::std::endl
+       << ".../foo.git#/tags/v*  - refs/tags/v1.2.3 only" << ::std::endl
+       << ::std::endl
+       << "While a \033[4mrefname\033[0m pattern is allowed not match any references, a non-pattern that" << ::std::endl
+       << "doesn't resolve to a reference is invalid." << ::std::endl
+       << ::std::endl
+       << "If a \033[4mrefname\033[0m starts with minus (\033[1m-\033[0m) then it is treated as an exclusion filter --" << ::std::endl
+       << "any references that it matches are excluded from the set included by the" << ::std::endl
+       << "preceding filters (or the default set). For example:" << ::std::endl
+       << ::std::endl
+       << ".../foo.git#v*,-v1.*  - exclude v1.* from v*" << ::std::endl
+       << ".../foo.git##-v1.*    - exclude v1.* from default set" << ::std::endl
+       << ::std::endl
+       << "To support specifying literal leading minus, a \033[4mrefname\033[0m that starts with plus" << ::std::endl
+       << "(\033[1m+\033[0m) is treated as an inclusion filter. For example:" << ::std::endl
+       << ::std::endl
+       << ".../foo.git#+x   - include  x" << ::std::endl
+       << ".../foo.git#+-x  - include -x" << ::std::endl
+       << ".../foo.git#++x  - include +x" << ::std::endl
+       << ::std::endl
+       << "Currently supported \033[1mgit\033[0m protocols are \033[1mgit://\033[0m, \033[1mssh://\033[0m (but not scp\033[0m pseudo-URL" << ::std::endl
+       << "syntax), \033[1mhttp://\033[0m, and \033[1mhttps://\033[0m for remote repositories and \033[1mfile://\033[0m for local" << ::std::endl
+       << "repositories. While \033[1mbpkg\033[0m tries to minimize the amount of information (history)" << ::std::endl
+       << "fetched, it is not always possible for some protocols and/or server" << ::std::endl
+       << "configurations, as discussed next." << ::std::endl
+       << ::std::endl
+       << "A \033[1mgit\033[0m repository accessible via \033[1mhttp(s)://\033[0m can use either \033[4mdumb\033[0m or \033[4msmart\033[0m" << ::std::endl
+       << "protocol (refer to the \033[1mgit\033[0m documentation for details). The dumb protocol" << ::std::endl
+       << "provides only limited support for fetch minimization and if this protocol is" << ::std::endl
+       << "used, then \033[1mbpkg\033[0m has no choice but to download a substantial amount of history." << ::std::endl
+       << ::std::endl
+       << "The smart protocol allows fetching of minimal history for tags and branches." << ::std::endl
+       << "Whether this is also possible for (all) commit ids depends on whether the" << ::std::endl
+       << "server is configured to allow fetching unadvertised commits. For details, refer" << ::std::endl
+       << "to the \033[1muploadpack.allowReachableSHA1InWant\033[0m and \033[1muploadpack.allowAnySHA1InWant\033[0m" << ::std::endl
+       << "\033[1mgit\033[0m configuration values." << ::std::endl
+       << ::std::endl
+       << "The \033[1mgit://\033[0m and \033[1mssh://\033[0m protocols are similar to smart \033[1mhttp://\033[0m in that they" << ::std::endl
+       << "support fetching minimal history for tags and branches and may or may not" << ::std::endl
+       << "support this for commit ids depending on the server configuration. Note," << ::std::endl
+       << "however, that unlike for \033[1mhttp(s)://\033[0m, for these protocols \033[1mbpkg\033[0m does not try to" << ::std::endl
+       << "sense if fetching unadvertised commits is allowed and always assumes that it is" << ::std::endl
+       << "not. Also note that the sensed or assumed protocol capabilities can be" << ::std::endl
+       << "overridden for a \033[1mgit\033[0m repository URL prefix using the \033[1m--git-capabilities\033[0m option" << ::std::endl
+       << "(\033[1mbpkg-common-options(1)\033[0m)." << ::std::endl
+       << ::std::endl
+       << "Based on this information, to achieve optimal results the recommended protocol" << ::std::endl
+       << "for remote repositories is smart \033[1mhttps://\033[0m. Additionally, if you are planning to" << ::std::endl
+       << "refer to unadvertised commit ids, then also consider configuring the server to" << ::std::endl
+       << "allow fetching unadvertised commits." << ::std::endl
+       << ::std::endl
+       << "The \033[1mfile://\033[0m protocol has the same fetch minimization support as \033[1mgit://\033[0m and is" << ::std::endl
+       << "therefore treated the same." << ::std::endl;
+
+    p = ::bpkg::cli::usage_para::text;
+
+    return p;
+  }
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
diff --git a/bpkg/repository-types.hxx b/bpkg/repository-types.hxx
new file mode 100644
index 0000000..b62deed
--- /dev/null
+++ b/bpkg/repository-types.hxx
@@ -0,0 +1,31 @@
+// -*- C++ -*-
+//
+// This file was generated by CLI, a command line interface
+// compiler for C++.
+//
+
+#ifndef BPKG_REPOSITORY_TYPES_HXX
+#define BPKG_REPOSITORY_TYPES_HXX
+
+// Begin prologue.
+//
+//
+// End prologue.
+
+#include <bpkg/common-options.hxx>
+
+// Print page usage information.
+//
+namespace bpkg
+{
+  ::bpkg::cli::usage_para
+  print_bpkg_repository_types_usage (::std::ostream&,
+                                     ::bpkg::cli::usage_para = ::bpkg::cli::usage_para::none);
+}
+
+// Begin epilogue.
+//
+//
+// End epilogue.
+
+#endif // BPKG_REPOSITORY_TYPES_HXX
diff --git a/buildfile b/buildfile
index da08ca9..09f1c20 100644
--- a/buildfile
+++ b/buildfile
@@ -1,7 +1,7 @@
 # file      : buildfile
 # license   : MIT; see accompanying LICENSE file
 
-./: {*/ -build/}                                          \
+./: {*/ -build/ -doc/}                                          \
     doc{INSTALL NEWS README} legal{LICENSE AUTHORS LEGAL} \
     manifest
 
diff --git a/repositories.manifest b/repositories.manifest
index 288344c..62acd9d 100644
--- a/repositories.manifest
+++ b/repositories.manifest
@@ -3,12 +3,5 @@ summary: build2 package dependency manager repository
 
 :
 role: prerequisite
-location: ../build2.git#HEAD
-
-:
-role: prerequisite
-location: ../libbutl.git#HEAD
-
-:
-role: prerequisite
-location: ../libbpkg.git#HEAD
+location: https://stage.build2.org/1
+trust: EC:50:13:E2:3D:F7:92:B4:50:0B:BF:2A:1F:7D:31:04:C6:57:6F:BC:BE:04:2E:E0:58:14:FA:66:66:21:1F:14