Wrap your implicit instance of AsReal, AsRaw, AsRawReal or RPC metadata (with companion that extends
RpcMetadataCompanion into Fallback in order to lower its implicit priority.
Useful when some implicit must be imported but we don't want it to get higher priority that imports normally
have over implicit scope (e.g. implicits from companion objects).

NOTE: Fallback does not work for *all* typeclasses, only RPC-related ones (AsReal, AsRaw, etc).
You can make it work with your own typeclass, but you must define appropriate forwarder in its companion, e.g.

Base trait for verbatim and encoded. These annotations can be applied either on a raw method or
raw parameter in order to specify how matching real method results or matching real parameter values are encoded
as raw values.
Currently there are two possible cases: verbatim (no encoding) and encoded (encoding using AsRaw and
AsReal typeclasses). By default, method return values and multi
parameters are encoded while single and
optional parameters are verbatim.
See documentation of verbatim and encoded for more details.

Intermediate factory that creates an InstancesTrait for given Real RPC trait, based on provided Implicits.

Intermediate factory that creates an InstancesTrait for given Real RPC trait, based on provided Implicits.
Normally, this factory is used as implicit constructor parameter of base classes for companion objects
of RPC traits (e.g. DefaultRestApiCompanion).
This all serves to reduce boilerplate associated with RPC trait companion declarations and makes RPC trait
definitions as concise as possible. It also lets the programmer easily inject additional implicits into
macro-materialization of RPC-related typeclasses (AsReal, AsRaw, metadata, etc.).

An InstancesTrait is a trait that aggregates multiple RPC related typeclass instances for given Real RPC trait.
There is no fixed interface for InstancesTrait, its members are inspected by materialize macro and implemented
automatically. InstancesTrait must contain only parameterless abstract methods that return either
AsRaw[Raw,Real], AsReal[Raw,Real], AsRawReal[Raw,Real] or some RPC metadata class for Real.
The Raw type is arbitrary and may be different for every method. However, it must be a concrete raw RPC trait
so that it's further understood by the macro engine. All methods of the InstancesTrait are macro-implemented
using AsRaw/AsReal/AsRawReal/RpcMetadata.materializeForRpc macros.

The Implicits type is typically a trait with a collection of implicit definitions whose companion object
implements that trait, e.g. DefaultRestImplicits.
When the macro implements apply method of RpcMacroInstances contents of Implicits are imported into the
body of apply and visible further by macros that materialize InstancesTrait.

If RpcMacroInstances is accepted as implicit super constructor parameter of a companion object
(which is the typical situation) then this reference should be passed as companion.
This is in order to work around https://github.com/scala/bug/issues/7666

Base trait for RPC tag annotations. Tagging gives more direct control over how real methods
and their parameters are matched against raw methods and their parameters.
For more information about method tagging, see documentation of methodTag.
For more information about parameter tagging, see documentation of paramTag.

When a raw parameter is annotated as encoded, macro generated code will translate
between real parameter values and raw parameter values using implicit instances of AsRaw[Raw,Real]
and AsReal[Raw,Real] typeclasses.

When a raw parameter is annotated as encoded, macro generated code will translate
between real parameter values and raw parameter values using implicit instances of AsRaw[Raw,Real]
and AsReal[Raw,Real] typeclasses. This annotation may also be applied on a method, but this would be
redundant since method results are encoded by default.

Here's an example of raw RPC definition supposed to handle asynchronous (Future-based) calls that uses
GenCodec in order to encode and decode arguments and results as JSON strings.
It introduces its own wrapper class for JSON strings that has appropriate implicit instances of
AsRaw and AsReal (or AsRawReal which serves as both AsReal and AsRaw).

If you don't want to introduce the wrapper Json class and use more raw type, e.g. plain String then you
can also do it by moving implicit instances of AsReal and AsRaw (or the joined AsRawReal) into the
implicits object of raw RPC companion:

May be applied on raw method parameter of type String to indicate that macro generated implementation of
AsReal should pass real method's RPC name as this parameter and that macro generated implementation of
AsRaw should expect real method's RPC name to be passed there.

May be applied on raw method parameter of type String to indicate that macro generated implementation of
AsReal should pass real method's RPC name as this parameter and that macro generated implementation of
AsRaw should expect real method's RPC name to be passed there.

Macro generation of AsRaw implementations require that raw methods annotated as
multi must take at least
one raw parameter annotated as methodName (it may also be aggregated into some
composite parameter).
This is necessary to properly identify which real method should be called.

In the example above, we created a hierarchy of annotations rooted at MethodType which can be used
on real methods in order to explicitly tell the RPC macro which raw methods can match it.
We also specify new GET as the default tag that will be assumed for real methods without any tag annotation.
Then, using tagged we specify that the raw get method may only match real methods annotated as GET
while post raw method may only match real methods annotated as POST.
Raw methods not annotated with tagged have no limitations and may still match any real methods.

Also, instead of specifying defaultTag in @methodTag annotation, you may provide the whenUntagged
parameter to tagged annotation. Raw method annotated as @tagged[MethodType](whenUntagged = new GET)
will match real methods either explicitly tagged with GET or untagged. If untagged, new GET will be assumed
as the tag. This is useful when you want to have multiple raw methods with different whenUntagged setting.

NOTE: The example above assumes there is a Json type defined with appropriate encodings -
see encoded for more details on parameter and method result encoding.

Parameter tagging lets you have more explicit control over which raw parameters can match which real
parameters.

Parameter tagging lets you have more explicit control over which raw parameters can match which real
parameters. This way you can have some of the parameters annotated in order to treat them differently, e.g.
they may be verbatim, encoded in a different way or collected to a different raw container (e.g.
Map[String,Raw] vs List[Raw] - see multi for more details).

You can use this annotation on overloaded RPC methods to give them unique identifiers for RPC serialization.

You can use this annotation on overloaded RPC methods to give them unique identifiers for RPC serialization.
You can also subclass this annotation provided that you always override the name parameter with another
constructor parameter.

You can use this annotation on real RPC methods to instruct macro engine to prepend method name (or rpcName if
specified) with given prefix.

You can use this annotation on real RPC methods to instruct macro engine to prepend method name (or rpcName if
specified) with given prefix. This annotation is mostly useful when aggregated by another annotation e.g.

Annotation applied on raw methods or raw parameters that limits matching real methods or real parameters to
only these annotated as Tag.

Annotation applied on raw methods or raw parameters that limits matching real methods or real parameters to
only these annotated as Tag. See methodTag and paramTag for more explanation. NOTE: Tag may
also be some common supertype of multiple tags which are accepted by this raw method or param.

When raw method is annotated as @tried, invocations of real methods matching that raw method will be
automatically wrapped into Try.

When raw method is annotated as @tried, invocations of real methods matching that raw method will be
automatically wrapped into Try. Consequently, all real methods will be treated as if their result
type was Try[Result] instead of actual Result. For example, if raw method is encoded and its
(raw) result is Raw then macro engine will search for implicit AsRaw/Real[Raw,Try[Result]] instead of just
AsRaw/Real[Raw,Result]

Turns off raw value encoding as specified by encoded. By default, single
and optional raw parameters are already verbatim, so using verbatim
only makes sense on multi raw parameters or raw methods themselves,
which means turning off encoding of method's result.

When encoding is turned off, raw and real types must be exactly the same types. For example, the following raw RPC
definition will match only raw RPC traits whose methods take Ints as parameters and return Doubles as values: