private class TestClassA : ISerializedObject
{
    public Guid someId;
    public float someFloatData;
    public TestClassB child;
    
    public Vector2 vec2Prop { get; set; }

	// This is the only method you are required to implement.
    // It's called for both serialization and deserialization,
    // so you don't need to add/remove/reorder fields
    // in two separate methods.
    public void Serialize(Serializer ioSerializer)
    {
    	// The general format for serialization methods is
        // Serialize(propertyKey, ref field, [default value (if supported by type)], [extra options])
        
        ioSerializer.Serialize("someId", ref someId);
        ioSerializer.Serialize("someFloatData", ref someFloatData);
        
        // You can even nest serialized objects inside of this one.
        // Note that methods for serializing objects start with Object instead of Serialize
        ioSerializer.Object("child", ref child);
        
        // Serializing C# properties instead of fields requires some extra work,
        // since you can't pass a property in by reference.
        // Because of this limitation, it's recommended you use fields instead of properties.
        if (ioSerializer.IsWriting)
        {
			Vector2 vec2PropCopy = vec2Prop;
            ioSerializer.Serialize("vec2Prop", ref vec2PropCopy);
		}
        else
        {
        	Vector2 vec2PropDest = default(Vector2);
            ioSerializer.Serialize("vec2Prop", ref vec2PropDest);
            vec2Prop = vec2PropDest;
        }
    }
}

private class TestClassB : ISerializedObject
{
	[...]
}

TestClassA testClassA = new TestClassA( ... );

// You can serialize to a string
string serializedObject = Serializer.Write(testClassA, OutputOptions.None, Serializer.Format.JSON);

// You can also serialize to a stream
Stream stream = [...];
Serializer.Write(testClassA, stream, OutputOptions.None, Serializer.Format.Binary);

// You can read from a string
string source = [...];
TestClassA deserializedFromString = Serializer.Read<TestClassA>(source);

// You can also read from a stream.
// Note that this is currently limited to streams containing only an ISerializedObject
Stream stream = [...];
TestClassA deserializedFromStream = Serializer.Read<TestClassA>(stream);

TypeUtility.RegisterAlias<TestClassA>("TestClassA");
TypeUtility.RegisterAlias<TestClassASubclass>("TestClassASubclass");

// where T is the serialized type
T[]
List<T>
HashSet<T>
Dictionary<int, T>
Dictionary<string, T>