+ wizard(
+ data => sub { ... },
+ get => sub { my ($ref, $data [, $op]) = @_; ... },
+ set => sub { my ($ref, $data [, $op]) = @_; ... },
+ len => sub {
+ my ($ref, $data, $len [, $op]) = @_; ... ; return $newlen
+ },
+ clear => sub { my ($ref, $data [, $op]) = @_; ... },
+ free => sub { my ($ref, $data [, $op]) = @_, ... },
+ copy => sub { my ($ref, $data, $key, $elt [, $op]) = @_; ... },
+ local => sub { my ($ref, $data [, $op]) = @_; ... },
+ fetch => sub { my ($ref, $data, $key [, $op]) = @_; ... },
+ store => sub { my ($ref, $data, $key [, $op]) = @_; ... },
+ exists => sub { my ($ref, $data, $key [, $op]) = @_; ... },
+ delete => sub { my ($ref, $data, $key [, $op]) = @_; ... },
+ copy_key => $bool,
+ op_info => [ 0 | VMG_OP_INFO_NAME | VMG_OP_INFO_OBJECT ],
+ )
+
+This function creates a 'wizard', an opaque object that holds the magic information.
+It takes a list of keys / values as argument, whose keys can be :
+
+=over 4
+
+=item *
+
+C<data>
+
+A code (or string) reference to a private data constructor.
+It is called in scalar context each time the magic is cast onto a variable, with C<$_[0]> being a reference to this variable and C<@_[1 .. @_-1]> being all extra arguments that were passed to L</cast>.
+The scalar returned from this call is then attached to the variable and can be retrieved later with L</getdata>.
+
+=item *
+
+C<get>, C<set>, C<len>, C<clear>, C<free>, C<copy>, C<local>, C<fetch>, C<store>, C<exists> and C<delete>
+
+Code (or string) references to the respective magic callbacks.
+You don't have to specify all of them : the magic corresponding to undefined entries will simply not be hooked.
+
+When those callbacks are executed, C<$_[0]> is a reference to the magic variable and C<$_[1]> is the associated private data (or C<undef> when no private data constructor is supplied with the wizard).
+Other arguments depend on which kind of magic is involved :
+
+=over 8
+
+=item *
+
+I<len>
+
+C<$_[2]> contains the natural, non-magical length of the variable (which can only be a scalar or an array as I<len> magic is only relevant for these types).
+The callback is expected to return the new scalar or array length to use, or C<undef> to default to the normal length.
+
+=item *
+
+I<copy>
+
+C<$_[2]> is a either an alias or a copy of the current key, and C<$_[3]> is an alias to the current element (i.e. the value).
+Because C<$_[2]> might be a copy, it is useless to try to change it or cast magic on it.
+
+=item *
+
+I<fetch>, I<store>, I<exists> and I<delete>
+
+C<$_[2]> is an alias to the current key.
+Note that C<$_[2]> may rightfully be readonly if the key comes from a bareword, and as such it is unsafe to assign to it.
+You can ask for a copy instead by passing C<< copy_key => 1 >> to L</wizard> which, at the price of a small performance hit, allows you to safely assign to C<$_[2]> in order to e.g. redirect the action to another key.
+
+=back
+
+Finally, if C<< op_info => $num >> is also passed to C<wizard>, then one extra element is appended to C<@_>.
+Its nature depends on the value of C<$num> :
+
+=over 8
+
+=item *