you can use a type for a rule in serialization

pkg/serialization/lib/serialization.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * A general-purpose serialization facility for Dart objects.
  *
  * A [Serialization] is defined in terms of [SerializationRule]s and supports
  * reading and writing to different formats.
  *
  * For information on installing and importing this library, see the
  * [serialization package on pub.dartlang.org]
  * (http://pub.dartlang.org/packages/serialization).
  *
  * ## Setup
  *
  * A simple example of usage is
  *
  *      var address = new Address();
  *      address.street = 'N 34th';
  *      address.city = 'Seattle';
  *      var serialization = new Serialization()
- *          ..addRuleFor(address);
+ *          ..addRuleFor(Address);
  *      Map output = serialization.write(address);
  *
- * This creates a new serialization and adds a rule for address objects. Right
- * now it has to be passed an address instance because of limitations using
- * Address as a literal. Then we ask the [Serialization] to write the address
+ * This creates a new serialization and adds a rule for address objects.
+ * Then we ask the [Serialization] to write the address
  * and we get back a Map which is a [json]able representation of the state of
  * the address and related objects. Note that while the output in this case
  * is a [Map], the type will vary depending on which output format we've told
  * the [Serialization] to use.
  *
  * The version above used reflection to automatically identify the public
  * fields of the address object. We can also specify those fields explicitly.
  *
  *      var serialization = new Serialization()
- *        ..addRuleFor(address,
+ *        ..addRuleFor(Address,
  *            constructor: "create",
  *            constructorFields: ["number", "street"],
  *            fields: ["city"]);
  *
  * This rule still uses reflection to access the fields, but does not try to
  * identify which fields to use, but instead uses only the "number" and "street"
  * fields that we specified. We may also want to tell it to identify the
  * fields, but to specifically omit certain fields that we don't want
  * serialized.
  *
  *      var serialization = new Serialization()
- *        ..addRuleFor(address,
+ *        ..addRuleFor(Address,
  *            constructor: "",
  *            excludeFields: ["other", "stuff"]);
  *
  * ## Writing rules
  *
  * We can also use a completely non-reflective rule to serialize and
  * de-serialize objects. This can be more work, but it does work in
  * dart2js, where mirrors are not yet implemented. We can specify this in two
  * ways. First, we can write our own SerializationRule class that has methods
  * for our Address class.
@@ skipping 121 matching lines @@
  * connected up to other instances on the receiving side. A notable example of
  * this is when serialization rules have been stored. Instances of BasicRule
  * take a [ClassMirror] in their constructor, and we cannot serialize those. So
  * when we read the rules, we must provide a Map<String, Object> which maps from
  * the simple name of classes we are interested in to a [ClassMirror]. This can
  * be provided either in the [Serialization.namedObjects],
  * or as an additional parameter to the reading and writing methods on the
  * [Reader] or [Writer] respectively.
  *
  *     new Serialization()
- *       ..addRuleFor(new Person(), constructorFields: ["name"])
+ *       ..addRuleFor(Person, constructorFields: ["name"])
  *       ..namedObjects['Person'] = reflect(new Person()).type;
  */
 library serialization;
 
 import 'src/mirrors_helpers.dart';
 import 'src/serialization_helpers.dart';
 import 'dart:collection';
 
 part 'src/reader_writer.dart';
 part 'src/serialization_rule.dart';
@@ skipping 288 matching lines @@
 }
 
 /**
  * An exception class for errors during serialization.
  */
 class SerializationException implements Exception {
   final String message;
   const SerializationException(this.message);
   String toString() => "SerializationException($message)";
 }