     if Object.keys(errors).length then return errors
     return null
 
-proto.extend = (aProto) ->
-    return
+gProto.extend = (aDefinitions) ->
+    if not _.isObject(aDefinitions) or Array.isArray(aDefinitions)
+        msg = "Definitions passed to .extend(aDefinitions) must be an Object."
+        throw new Error(msg)
+
+    return createModel(@, aDefinitions)
 
 
 exports.create = (aDefinitions) ->
-    definitions = Object.create(null)
-
-    for own key, val of aDefinitions
-        try
-            def = normalizeDefinition(val)
-        catch message
-            throw new Error("Definition error '#{key}': #{message}")
-
-        Object.defineProperty(definitions, key, {
-            enumerable: yes
-            value: def
-        })
-
-    self = Object.create(null, {
-        definitions:
+    if not _.isObject(aDefinitions) or Array.isArray(aDefinitions)
+        msg = "Definitions passed to create(aDefinitions) must be an Object."
+        throw new Error(msg)
+
+    return createModel(gProto, aDefinitions)
+
+
+createModel = do ->
+
+    # Extend an object using Object.defineProperty().
+    extend = (target, source) ->
+        for own key, val of source
+            if key isnt 'definitions'
+                Object.defineProperty(target, key, {
+                    enumerable: yes
+                    value: val
+                })
+        return target
+
+    create = (aParent, aChild) ->
+        model = Object.create(null)
+        # Only extend the methods of the parent object. The child object is
+        # just a definition dictionary.
+        model = extend(model, aParent)
+
+        # Create and extend the definitions with the .definitions property of
+        # the parent, the the child Object, which is the new definition
+        # dictionary.
+        definitions = extendDefinitions(aParent.definitions, aChild)
+        Object.defineProperty(model, 'definitions', {
             value: Object.freeze(definitions)
-        create:
-            enumerable: yes
-            value: proto.create
-        clean:
-            enumerable: yes
-            value: proto.clean
-        coerce:
-            enumerable: yes
-            value: proto.coerce
-        validate:
-            enumerable: yes
-            value: proto.validate
-    })
-
-    return Object.freeze(self)
-
-
-create = () ->
-    model = Object.create(null)
-    return Object.freeze(model)
+        })
+
+        # Freeze it to prevent accidental tampering.
+        return Object.freeze(model)
+
+    return create
 
 
 extendDefinitions = do ->

        return no
})

exports.proto = proto = Object.create(null)

proto.create = ->
    defs = @definitions
    rv = Object.keys(defs).reduce((rv, key) ->
        rv[key] = if _.hasProperty(defs[key], 'defaultValue')

        })
        return definitions

    extend = (aParent, aChild) ->
        defs = Object.create(null)

        defs = Object.keys(aParent).reduce((defs, key) ->
            return define(defs, key, aParent[key])
        , Object.create(null))

        defs = Object.keys(aChild).reduce((defs, key) ->
            return define(defs, key, aChild[key])
        , defs)

        return defs
