namespace boost {
  namespace taar {
    std::optional< double > 
    accept_encoding_quality(std::string_view, std::string_view);
  }
}

namespace boost {
  namespace taar {
    template<typename T> class async_channel;
  }
}

namespace boost {
  namespace taar {
    template<typename T> class async_generator;
  }
}

namespace boost {
  namespace taar {
    template<typename T> 
    using awaitable = boost::asio::awaitable< T, boost::asio::any_io_executor >;

    constexpr boost::asio::use_awaitable_t< boost::asio::any_io_executor > use_awaitable;    // Completion token: continue this coroutine, throw on error. 
    constexpr boost::asio::as_tuple_t< boost::asio::use_awaitable_t< boost::asio::any_io_executor > > use_awaitable_tuple;    // Completion token: continue this coroutine, return (error_code, result) instead of throwing. 
  }
}

namespace boost {
  namespace taar {

    // Standard base64 (RFC 4648) with padding, as MCP binary content requires. 
    std::string base64_encode(std::string_view bytes);

    // Decode standard base64; nullopt on malformed input. 
    std::optional< std::string > base64_decode(std::string_view text);
  }
}

namespace boost {
  namespace taar {
    class body_reader;

    struct streaming_request;
  }
}

namespace boost {
  namespace taar {
    struct byte_range;
    struct range_set;

    // Outcome of parse_range. 
    enum range_status { ignored, satisfiable, unsatisfiable };
    range_set parse_range(std::string_view, std::uint64_t, std::size_t = 16);
    std::vector< byte_range > coalesce_ranges(std::vector< byte_range >);
  }
}

namespace boost {
  namespace taar {
    class cancellation_signals;
  }
}

namespace boost {
  namespace taar {
    template<has_chunk_body_from T> std::string chunk_body_from(T &&);
  }
}

namespace boost {
  namespace taar {
    template<typename T> struct chunk_body_from_tag;
  }
}

namespace boost {
  namespace taar {
    template<typename T> class chunked_response;
  }
}

namespace boost {
  namespace taar {
    struct chunked_set_header;
    struct chunked_set_status;

    // Build a chunked_set_status token. Convenience factory. 
    chunked_set_status set_status(boost::beast::http::status s);

    // Build a chunked_set_header token for a well-known Beast field. 
    chunked_set_header set_header(boost::beast::http::field f, std::string v);

    // Build a chunked_set_header token for an arbitrary header name. 
    chunked_set_header set_header(std::string name, std::string v);
  }
}

namespace boost {
  namespace taar {
    template<std::size_t N> struct constexpr_string;
    namespace literals {
      template<constexpr_string CS> constexpr auto operator""_cs();
    }
  }
}

namespace boost {
  namespace taar {
    template<typename Key, typename Context> class context_store;

    template<typename Key> struct default_key_generator;

    template<> struct default_key_generator<std::string>;
  }
}

namespace boost {
  namespace taar {
    struct cookie;

    class cookies;
  }
}

namespace boost {
  namespace taar {
    struct cors;
  }
}

namespace boost {
  namespace taar {
    struct entity_tag;
    std::optional< entity_tag > parse_entity_tag(std::string_view &);

    // Strong comparison: both tags are strong and their opaque parts equal. 
    bool strong_match(entity_tag const & a, entity_tag const & b);

    // Weak comparison: the opaque parts are equal, whatever the weakness. 
    bool weak_match(entity_tag const & a, entity_tag const & b);
    bool etag_list_matches(std::string_view, std::string_view, bool);
  }
}

namespace boost {
  namespace system {
    template<> struct is_error_code_enum<::boost::taar::error>;
  }
  namespace taar {
    class exception;
    class failure;

    enum error;
    template<typename T> 
    using result = boost::system::result< T, failure >;

    // Singleton boost::system::error_category instance for the error enum. 
    boost::system::error_category const & error_category();

    // ADL-found factory required by is_error_code_enum<error>. 
    boost::system::error_code make_error_code(error ev);
    void throw_exception_from_error(failure const &, 
                                    boost::source_location const &);
    boost::beast::http::status http_status_for(failure const &);
  }
}

namespace boost {
  namespace system {
    template<> struct is_error_code_enum<::boost::taar::jsonrpc::error>;
  }
  namespace taar {
    namespace jsonrpc {
      enum error;

      // Singleton boost::system::error_category instance for error. 
      boost::system::error_category const & error_category();

      // ADL-found factory required by is_error_code_enum<error>. 
      boost::system::error_code make_error_code(error ev);
    }
  }
}

namespace boost {
  namespace system {
    template<> struct is_error_code_enum<::boost::taar::mcp::error>;
  }
  namespace taar {
    namespace mcp {
      enum error;

      // Singleton boost::system::error_category instance for error. 
      boost::system::error_category const & error_category();

      // ADL-found factory required by is_error_code_enum<error>. 
      boost::system::error_code make_error_code(error ev);
    }
  }
}

namespace boost {
  namespace taar {
    typedef std::unordered_map< std::string, std::string > form_kvp;
  }
}

namespace boost {
  namespace taar {
    std::string format_http_date(std::chrono::system_clock::time_point);
    std::optional< std::chrono::sys_seconds > 
    parse_http_date(std::string_view);
  }
}

namespace boost {
  namespace taar {
    struct ignore_and_rethrow_t;

    static ignore_and_rethrow_t const ignore_and_rethrow;    // Stateless instance of ignore_and_rethrow_t. 
  }
}

namespace boost {
  namespace taar {
    typedef std::optional< boost::beast::http::response< boost::beast::http::string_body > > interceptor_result;

    // Let the request proceed (std::nullopt). 
    interceptor_result proceed();
    interceptor_result 
    reject(boost::beast::http::status, std::string_view = {});
  }
}

namespace boost {
  namespace taar {
    template<typename T> struct async_generator_value;

    template<typename T> struct async_generator_value<async_generator< T >>;

    template<typename T> 
    using async_generator_value_t = typename async_generator_value< T >::type;  // Convenience alias for async_generator_value<T>::type. 
  }
}

namespace boost {
  namespace taar {
    template<typename T> struct awaitable_result;

    template<typename T, typename E> 
      struct awaitable_result<boost::asio::awaitable< T, E >>;

    template<typename T> 
    using awaitable_result_t = typename awaitable_result< T >::type;
  }
}

namespace boost {
  namespace taar {
    template<typename T> struct chunked_response_value;

    template<typename T> struct chunked_response_value<chunked_response< T >>;

    template<typename T> 
    using chunked_response_value_t = typename chunked_response_value< T >::type;  // Convenience alias for chunked_response_value<T>::type. 
  }
}

namespace boost {
  namespace taar {
    struct param_info;

    constexpr bool is_optional_v;    // True if T (after stripping cv/ref) is a std::optional. 
    template<typename T> boost::json::object json_schema_for();

    // The JSON Schema type name for T (empty for "any"). Shorthand over json_schema_for. 
    template<typename T> std::string json_type_name();

    // Build a param_info for a parameter of type T. 
    template<typename T> 
      param_info make_param_info(std::string name, std::string description, 
                                 bool required);

    // A parameter's type schema: its schema (or the bare type) plus default, without description. 
    boost::json::object param_type_schema(param_info const & p);

    // A JSON Schema fragment for one parameter: param_type_schema plus description. 
    boost::json::object param_schema(param_info const & p);

    // A JSON Schema object with properties and required built from params. 
    boost::json::object 
    object_schema(std::vector< param_info > const & params);
  }
}

namespace boost {
  namespace taar {
    template<typename T, typename U> struct is_member_function_of;

    constexpr bool is_member_function_of_v;    // Convenience variable template for is_member_function_of. 
  }
}

namespace boost {
  namespace taar {
    std::string file_extension(std::string_view);
    std::string_view mime_type_for(std::string_view);
    bool is_text_mime_type(std::string_view);

    // type with ; charset=utf-8 appended when it is a text type (is_text_mime_type) that carries no parameter yet; otherwise type unchanged. 
    std::string with_utf8_charset(std::string_view type);
  }
}

namespace boost {
  namespace taar {
    struct multipart_form;
    struct multipart_part;
    struct multipart_part_header;

    class multipart_reader;
    std::optional< std::string > multipart_boundary(std::string_view);
    multipart_form parse_multipart(std::string_view, std::string_view);
  }
}

namespace boost {
  namespace taar {
    template<typename T> 
    using rebind_executor = typename T::template rebind_executor< boost::asio::as_tuple_t< boost::asio::use_awaitable_t< boost::asio::any_io_executor > >::executor_with_default< boost::asio::any_io_executor > >::other;
  }
}

namespace boost {
  namespace taar {
    class request_attributes;
  }
}

namespace boost {
  namespace taar {
    class response_builder;
  }
}

namespace boost {
  namespace taar {
    template<has_response_from... T> 
    using response_from_t = std::invoke_result_t< decltype(response_from< T... >), T... >;  // The result type produced by response_from for argument pack T.... 
    template<has_response_from... T> constexpr auto response_from(T &&...);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
    template<typename CallableType, typename... ArgsType> 
      auto response_from_invoke(CallableType && callable, ArgsType &&... args);
  }
}

namespace boost {
  namespace taar {
    template<typename... T> struct response_from_tag;
  }
}

namespace boost {
  namespace taar {
    struct segmented_body;
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      template<typename ArgProviderType> struct constrained;
      struct constraints;
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      template<typename... Context> 
      using contexts = std::tuple< std::shared_ptr< Context >... >;
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      template<typename Check, typename Inner> struct guard_handler;
      template<typename Check, typename Inner> auto guard(Check, Inner);
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      struct cache_rule;

      class htdocs;

      struct htdocs_cache_stats;
      struct htdocs_options;
      namespace cache_rules {
        bool glob_match(std::string_view, std::string_view);
        bool looks_content_hashed(std::string_view);

        // The usual policy for bundled front ends: content-hashed file names (looks_content_hashed) are cached for a year as immutable, and HTML documents are revalidated on every use (no-cache). 
        std::vector< cache_rule > immutable_hashed();
      }
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      constexpr std::size_t find_target_index_v;      // Find the first target_constraint leaf's index in an AST's flattened leaves. 
      template<typename Operand> auto find_target_template(Operand const &);
      template<typename Operand, typename Handler> 
        void validate_path_args_against_target(Operand const &, 
                                               Handler const &);
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      template<typename CallableType, typename... ArgProvidersType> 
        decltype(auto) rest(CallableType &&, ArgProvidersType...);

      // Adapt a member-function pointer bound to object into an HTTP request handler. 
      template<typename MemFnType, typename ObjectType, 
               typename... ArgProvidersType> 
        decltype(auto) 
        rest(MemFnType memfn, ObjectType && object, 
             ArgProvidersType... arg_providers);
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      struct all_content_types_t;
      template<typename T> struct attribute_arg;
      struct body_size_arg;
      struct cookie_arg;
      struct description;
      struct header_arg;
      struct json_body_arg;
      struct multipart_form_arg;
      struct multipart_stream_arg;
      struct path_arg;
      struct query_arg;
      struct query_list_arg;
      struct stream_body_arg;
      struct string_body_arg;
      struct target_arg;
      struct url_encoded_form_data_arg;
      template<typename ArgProviderType, typename ValueType> struct with_default;

      constexpr all_content_types_t all_content_types;      // Pass to a body provider to accept any Content-Type. 
      template<typename HandlerArgType, typename ArgProviderType, 
               typename RequestType> 
        decltype(auto) 
        get_rest_arg(ArgProviderType const &, std::size_t, 
                     RequestType const &, matcher::context const &);
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      template<typename ToType, typename FromType> 
      using rest_arg_cast_result_t = decltype(rest_arg_cast< ToType >(std::declval< FromType >()));
      template<typename ToType, typename FromType> 
        constexpr decltype(auto) rest_arg_cast(FromType const &);
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      template<typename ToType> struct rest_arg_cast_tag;
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      struct rest_param_info;

      // Where a REST argument provider reads its value from. 
      enum param_location { path, query, header, cookie, body, none };
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {

      // How with_session treats a request whose key is absent or unknown. 
      enum session_policy { create_if_missing, require };
      namespace session_key {
        struct cookie;
        struct header;
      }
    }
  }
}

namespace boost {
  namespace taar {
    namespace handler {
      template<typename Store, typename KeyExtractor, typename Inner> 
        struct with_session_handler;
      template<typename Key, typename Context, typename KeyExtractor, 
               typename Inner> 
        auto with_session(context_store< Key, Context > &, KeyExtractor, 
                          session_policy, Inner);
    }
  }
}

namespace boost {
  namespace taar {
    namespace jsonrpc {
      struct call;
      struct rpc_arg;
    }
  }
}

namespace boost {
  namespace taar {
    namespace mcp {
      struct mcp_arg;
      struct resource_call;
      struct tool_call;
      struct uri_arg;

      // True if uri contains a {name} placeholder. 
      bool is_uri_template(std::string_view uri);
      std::optional< std::unordered_map< std::string, std::string > > 
      match_uri_template(std::string_view, std::string_view);
    }
  }
}

namespace boost {
  namespace taar {
    namespace jsonrpc {
      template<typename... Context> class endpoint;

      struct error_info;
      struct method_info;
      typedef std::function< error_info(taar::failure const &)> error_mapper;
      error_info default_error_mapper(taar::failure const &);

      // The spec's default message for code. 
      std::string message_for(error code);
    }
  }
}

namespace boost {
  namespace taar {
    namespace mcp {
      struct client_capabilities;
      struct client_info;
      struct completion_request;
      struct completion_result;

      template<typename Session = stateless, typename... Context> class endpoint;

      struct initialize_params;
      struct prompt_info;
      struct resource_info;
      struct server_info;
      struct session_info;
      struct stateless;
      struct tool_annotations;
      struct tool_info;
      struct tool_spec;

      // MCP logging levels (RFC 5424 names), least to most severe. 
      enum log_level { debug, info, notice, warning, error, critical, alert, 
                       emergency };
      typedef std::function< std::optional< std::string >(taar::failure const &)> tool_error_handler;
      typedef tool_call prompt_call;  // What an MCP prompt callable's argument providers receive (same shape as tool_call). 

      constexpr std::array< std::string_view, 8 > log_level_names;
      constexpr std::array< std::string_view, 3 > supported_protocol_versions;      // Protocol revisions this implementation can speak, newest first. 
      constexpr std::string_view latest_protocol_version;
      constexpr int resource_not_found_code;      // JSON-RPC error code MCP assigns to an unknown resource URI (error::resource_not_found). 
      std::string_view to_string(log_level level);
      std::optional< log_level > parse_log_level(std::string_view name);
      bool is_supported_protocol_version(std::string_view v);
      std::optional< std::string > 
      default_tool_error_handler(taar::failure const &);
    }
  }
}

namespace boost {
  namespace taar {
    namespace jsonrpc {
      struct envelope;

      // True if env carries no id and is therefore a notification. 
      bool is_notification(envelope const & env);
      boost::system::result< envelope > 
      parse_envelope(boost::json::value const &);
    }
  }
}

namespace boost {
  namespace taar {
    namespace jsonrpc {
      class request_scope;

      constexpr int request_cancelled_code;      // JSON-RPC error code reported when a request was cancelled before it produced a result. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace jsonrpc {
      boost::json::value make_response(boost::json::value, boost::json::value);
      boost::json::value 
      make_error_response(boost::json::value, int, std::string, 
                          std::optional< boost::json::value > = std::nullopt);
      boost::json::value 
      make_error_response(boost::json::value, error, std::string, 
                          std::optional< boost::json::value > = std::nullopt);
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      struct context;
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      template<typename FieldsType = boost::beast::http::fields> struct cookie_t;

      constexpr auto basic_cookie;      // A cookie-matcher placeholder parameterised by the Fields type. 
      constexpr auto cookie;      // The default cookie-matcher placeholder. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      template<typename FieldsType = boost::beast::http::fields> struct header_t;

      constexpr auto basic_header;      // A header-matcher placeholder parameterised by the Fields type. 
      constexpr auto header;      // The default header-matcher placeholder. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      template<typename L, typename R> struct and_;
      struct any_metadata;
      template<typename A, typename B> struct concat_;

      template<typename... A, typename... B> 
        struct concat_<type_list< A... >, type_list< B... >>;

      struct cookie_constraint_value;
      struct cookie_eq_constraint;
      struct cookie_exists_constraint;
      struct cookie_ne_constraint;
      template<typename Tag> struct data_of;

      template<> struct data_of<cookie_eq_constraint>;
      template<> struct data_of<cookie_exists_constraint>;
      template<> struct data_of<cookie_ne_constraint>;
      template<> struct data_of<header_eq_constraint>;
      template<> struct data_of<header_exists_constraint>;
      template<> struct data_of<header_ne_constraint>;
      template<> struct data_of<method_eq_constraint>;
      template<> struct data_of<method_ne_constraint>;
      template<> struct data_of<target_constraint>;
      template<> struct data_of<version_eq_constraint>;
      template<> struct data_of<version_ge_constraint>;
      template<> struct data_of<version_gt_constraint>;
      template<> struct data_of<version_le_constraint>;
      template<> struct data_of<version_lt_constraint>;
      template<> struct data_of<version_ne_constraint>;

      template<typename TL> struct data_tuple_impl_;

      template<typename... L> struct data_tuple_impl_<type_list< L... >>;

      template<typename AST> struct flatten;

      template<typename L, typename R> struct flatten<and_< L, R >>;
      template<> struct flatten<any_metadata>;
      template<typename X> struct flatten<not_< X >>;
      template<typename L, typename R> struct flatten<or_< L, R >>;

      struct header_constraint_value;
      struct header_eq_constraint;
      struct header_exists_constraint;
      struct header_ne_constraint;
      template<typename TL> struct list_size;

      template<typename... T> struct list_size<type_list< T... >>;

      struct method_constraint_value;
      struct method_eq_constraint;
      struct method_ne_constraint;
      template<typename X> struct not_;
      template<typename L, typename R> struct or_;
      struct target_constraint;
      struct target_constraint_value;
      template<typename... T> struct type_list;
      struct version_constraint_value;
      struct version_eq_constraint;
      struct version_ge_constraint;
      struct version_gt_constraint;
      struct version_le_constraint;
      struct version_lt_constraint;
      struct version_ne_constraint;

      typedef std::variant< boost::beast::http::field, std::string > header_key;  // Either a well-known beast field or an arbitrary header name. 
      typedef std::variant< boost::beast::http::verb, std::string > method_verb;  // Either a well-known beast verb or an arbitrary verb string. 
      template<typename Tag> 
      using data_of_t = typename data_of< Tag >::type;
      template<typename AST> 
      using flatten_t = typename flatten< AST >::type;  // Convenience alias for flatten<AST>::type. 
      template<typename AST> 
      using data_tuple_t = typename data_tuple_impl_< flatten_t< AST > >::type;

      constexpr std::size_t list_size_v;      // Convenience variable template for list_size. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      template<typename FieldsType = boost::beast::http::fields> struct method_t;

      constexpr auto basic_method;      // A method-matcher placeholder parameterised by the Fields type. 
      constexpr auto method;      // The default method-matcher placeholder. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      template<typename RequestType, typename CallableType, 
               typename Metadata = any_metadata> 
        class operand;
      template<typename LReq, typename LCall, typename LMeta, typename RReq, 
               typename RCall, typename RMeta> 
        auto operator&&(operand< LReq, LCall, LMeta > lhs, 
                        operand< RReq, RCall, RMeta > rhs);
      template<typename LReq, typename LCall, typename LMeta, typename RReq, 
               typename RCall, typename RMeta> 
        auto operator||(operand< LReq, LCall, LMeta > lhs, 
                        operand< RReq, RCall, RMeta > rhs);
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      struct route_input;
      struct route_shape;
      template<typename AST> struct route_shape_of;

      template<typename L, typename R> struct route_shape_of<and_< L, R >>;
      template<> struct route_shape_of<cookie_eq_constraint>;
      template<> struct route_shape_of<cookie_exists_constraint>;
      template<> struct route_shape_of<header_eq_constraint>;
      template<> struct route_shape_of<header_exists_constraint>;
      template<> struct route_shape_of<method_eq_constraint>;
      template<typename X> struct route_shape_of<not_< X >>;
      template<typename L, typename R> struct route_shape_of<or_< L, R >>;
      template<> struct route_shape_of<target_constraint>;
      template<> struct route_shape_of<version_eq_constraint>;
      template<> struct route_shape_of<version_ge_constraint>;
      template<> struct route_shape_of<version_gt_constraint>;
      template<> struct route_shape_of<version_le_constraint>;
      template<> struct route_shape_of<version_lt_constraint>;
      template<> struct route_shape_of<version_ne_constraint>;

      struct route_summary;

      constexpr bool route_expressible_v;      // True if an AST is a conjunction of exactly one target == ... and at least one method == ... (several may be joined with ||), plus any number of header, cookie and version constraints. 

      // Read the methods, path template, headers and cookies of an expressible operand. 
      template<typename Operand> 
        route_summary summarize_route(Operand const & op);
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      template<typename FieldsType = boost::beast::http::fields> struct target_t;

      constexpr auto basic_target;      // A target-matcher placeholder parameterised by the Fields type. 
      constexpr auto target;      // The default target-matcher placeholder. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      struct template_segment;
      struct template_segment_ref;

      // Kind of a single segment in a parsed path template. 
      enum template_segment_type { literal, param, greedy_param };

      typedef std::vector< template_segment > parsed_template;  // Owning vector of template_segment values. 
      typedef std::vector< template_segment_ref > parsed_template_ref;  // Non-owning vector of template_segment_ref values. 
      result< parsed_template_ref > parse_template(std::string_view);
    }
  }
}

namespace boost {
  namespace taar {
    namespace matcher {
      template<typename FieldsType = boost::beast::http::fields> struct version_t;

      constexpr auto basic_version;      // A version-matcher placeholder parameterised by the Fields type. 
      constexpr auto version;      // The default version-matcher placeholder. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace mcp {
      struct audio;
      struct blob;
      struct embedded_resource;
      struct image;
      struct text;
      struct tool_result;

      typedef std::variant< text, image, audio, embedded_resource > content_item;  // Any one content item. 
      void tag_invoke(boost::json::value_from_tag, boost::json::value & v, 
                      text const & t);
      void tag_invoke(boost::json::value_from_tag, boost::json::value & v, 
                      image const & i);
      void tag_invoke(boost::json::value_from_tag, boost::json::value & v, 
                      audio const & a);
      void tag_invoke(boost::json::value_from_tag, boost::json::value & v, 
                      blob const & b);
      void tag_invoke(boost::json::value_from_tag, boost::json::value & v, 
                      embedded_resource const & r);
      void tag_invoke(boost::json::value_from_tag, boost::json::value & v, 
                      content_item const & c);
      void tag_invoke(boost::json::value_from_tag, boost::json::value & v, 
                      tool_result const & r);
    }
  }
}

namespace boost {
  namespace taar {
    namespace openapi {
      class generator;

      struct info;
      struct operation;
      struct security_scheme;
      struct server;
    }
  }
}

namespace boost {
  namespace taar {
    namespace server {
      template<typename SessionHandler> 
        awaitable< void > 
        tcp(boost::asio::any_io_executor, std::string, std::string, 
            SessionHandler &&, cancellation_signals &, 
            std::function< void(boost::asio::ip::tcp::endpoint const &)> = nullptr);
      template<typename SessionHandler> 
        awaitable< void > 
        tcp(std::string, std::string, SessionHandler &&, 
            cancellation_signals &, 
            std::function< void(boost::asio::ip::tcp::endpoint const &)> = nullptr);
    }
  }
}

namespace boost {
  namespace taar {
    namespace server {
      template<typename SessionHandler> 
        awaitable< void > 
        tls(boost::asio::any_io_executor, std::string, std::string, 
            boost::asio::ssl::context &, SessionHandler &&, 
            cancellation_signals &, 
            std::function< void(boost::asio::ip::tcp::endpoint const &)> = nullptr, 
            std::chrono::steady_clock::duration = std::chrono::seconds {30});
      template<typename SessionHandler> 
        awaitable< void > 
        tls(std::string, std::string, boost::asio::ssl::context &, 
            SessionHandler &&, cancellation_signals &, 
            std::function< void(boost::asio::ip::tcp::endpoint const &)> = nullptr, 
            std::chrono::steady_clock::duration = std::chrono::seconds {30});
    }
  }
}

namespace boost {
  namespace taar {
    namespace session {
      template<typename Context = no_context, 
               typename Stream = boost::beast::tcp_stream> 
        class basic_http;

      struct no_context;
      typedef basic_http<> http;
    }
  }
}

namespace boost {
  namespace taar {
    namespace session {
      typedef boost::beast::ssl_stream< boost::beast::tcp_stream > tls_stream;  // The stream an HTTPS session runs on: TLS over Beast's plain tcp_stream. 
      template<typename Context = no_context> 
      using basic_https = basic_http< Context, tls_stream >;
      typedef basic_https<> https;  // HTTPS session without a per-connection context. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace type_traits {
      template<typename CallableType> struct callable;

      template<has_call_operator CallableType> struct callable<CallableType>;
      template<typename ResultType, typename... ArgsType> 
        struct callable<ResultType(*)(ArgsType...)>;
      template<typename ResultType, typename... ArgsType> 
        struct callable<ResultType(ArgsType...)>;
      template<typename ResultType, typename ObjectType, typename... ArgsType> 
        struct callable<ResultType(ObjectType::*)(ArgsType...) const>;
      template<typename ResultType, typename ObjectType, typename... ArgsType> 
        struct callable<ResultType(ObjectType::*)(ArgsType...)>;

      template<typename CallableType, std::size_t N> 
      using callable_arg = typename callable< CallableType >::template arg< N >;  // The N-th parameter type of CallableType. 
      template<typename CallableType> 
      using callable_result = typename callable< CallableType >::result;  // The result type of CallableType. 
      template<typename CallableType> 
      using callable_signature = typename callable< CallableType >::signature;  // The function signature of CallableType (as R(Args...)). 

      constexpr auto callable_args_count;      // The number of parameters of CallableType. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace type_traits {
      template<template< typename... > class, typename> 
        struct is_specialization_of;

      template<template< typename... > class TemplateType, 
               typename... ArgsType> 
        struct is_specialization_of<TemplateType, TemplateType< ArgsType... >>;

      constexpr bool is_specialization_of_v;      // Convenience variable template for is_specialization_of. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace type_traits {
      template<typename T> 
      using is_string_like = std::is_constructible< std::string, T >;  // Trait: value is true if std::string can be constructed from T. 

      constexpr bool is_string_like_v;      // Convenience variable template for is_string_like. 
    }
  }
}

namespace boost {
  namespace taar {
    namespace type_traits {
      template<typename... T> struct have_super_type;

      template<typename T> struct have_super_type<T>;
      template<typename T, typename U> struct have_super_type<T, U>;
      template<typename T, typename U, typename... Rest> 
        struct have_super_type<T, U, Rest...>;

      template<typename... T> struct super_type;

      template<typename T> struct super_type<T>;
      template<typename T, typename U> struct super_type<T, U>;
      template<typename T, typename U, typename... Rest> 
        struct super_type<T, U, Rest...>;

      template<typename... T> 
      using super_type_t = typename super_type< T... >::type;  // Convenience alias for super_type<T...>::type. 

      constexpr bool have_super_type_v;      // Convenience variable template for have_super_type. 
    }
  }
}