diff --git a/ckanext/metadata/lib/dictization/model_dictize.py b/ckanext/metadata/lib/dictization/model_dictize.py
index 093a767..9a6b463 100644
--- a/ckanext/metadata/lib/dictization/model_dictize.py
+++ b/ckanext/metadata/lib/dictization/model_dictize.py
@@ -73,9 +73,9 @@ def metadata_record_activity_dictize(activity, context):
     return activity_dict
 
 
-def metadata_model_dictize(metadata_model, context):
-    return _object_dictize(metadata_model, ckanext_model.MetadataModel, ckanext_model.MetadataModelRevision,
-                           ckanext_model.metadata_model_revision_table, context)
+def metadata_schema_dictize(metadata_schema, context):
+    return _object_dictize(metadata_schema, ckanext_model.MetadataSchema, ckanext_model.MetadataSchemaRevision,
+                           ckanext_model.metadata_schema_revision_table, context)
 
 
 def metadata_standard_dictize(metadata_standard, context):
diff --git a/ckanext/metadata/lib/dictization/model_save.py b/ckanext/metadata/lib/dictization/model_save.py
index 753a05a..aacdd18 100644
--- a/ckanext/metadata/lib/dictization/model_save.py
+++ b/ckanext/metadata/lib/dictization/model_save.py
@@ -67,9 +67,9 @@ def metadata_record_infrastructure_list_save(infrastructure_dicts, context):
             session.add(member_obj)
 
 
-def metadata_model_dict_save(metadata_model_dict, context):
-    return _object_dict_save(metadata_model_dict, 'metadata_model', ckanext_model.MetadataModel,
-                             ckanext_model.metadata_model_table, context)
+def metadata_schema_dict_save(metadata_schema_dict, context):
+    return _object_dict_save(metadata_schema_dict, 'metadata_schema', ckanext_model.MetadataSchema,
+                             ckanext_model.metadata_schema_table, context)
 
 
 def metadata_standard_dict_save(metadata_standard_dict, context):
diff --git a/ckanext/metadata/logic/__init__.py b/ckanext/metadata/logic/__init__.py
index 2e2c232..747a9cb 100644
--- a/ckanext/metadata/logic/__init__.py
+++ b/ckanext/metadata/logic/__init__.py
@@ -11,7 +11,7 @@
     'infrastructure': {'class': ckan_model.Group, 'desc': u'Infrastructure'},
     'metadata_collection': {'class': ckan_model.Group, 'desc': u'Metadata Collection'},
     'metadata_record': {'class': ckan_model.Package, 'desc': u'Metadata Record'},
-    'metadata_model': {'class': ckanext_model.MetadataModel, 'desc': u'Metadata Model'},
+    'metadata_schema': {'class': ckanext_model.MetadataSchema, 'desc': u'Metadata Schema'},
     'metadata_standard': {'class': ckanext_model.MetadataStandard, 'desc': u'Metadata Standard'},
     'workflow_state': {'class': ckanext_model.WorkflowState, 'desc': u'Workflow State'},
     'workflow_transition': {'class': ckanext_model.WorkflowTransition, 'desc': u'Workflow Transition'},
diff --git a/ckanext/metadata/logic/action/create.py b/ckanext/metadata/logic/action/create.py
index 16fa481..d42129f 100644
--- a/ckanext/metadata/logic/action/create.py
+++ b/ckanext/metadata/logic/action/create.py
@@ -72,43 +72,43 @@ def metadata_standard_create(context, data_dict):
     return output
 
 
-def metadata_model_create(context, data_dict):
+def metadata_schema_create(context, data_dict):
     """
-    Create a new metadata model.
+    Create a new metadata schema.
 
-    You must be authorized to create metadata models.
+    You must be authorized to create metadata schemas.
 
-    A model must be one and only one of the following:
+    A metadata schema must be one and only one of the following:
     - the default for the given metadata standard (no organization or infrastructure)
     - associated with an organization
     - associated with an infrastructure
 
-    Any metadata records that are now dependent on this model are invalidated.
+    Any metadata records that are now dependent on this schema are invalidated.
 
-    :param id: the id of the metadata model (optional - only sysadmins can set this)
+    :param id: the id of the metadata schema (optional - only sysadmins can set this)
     :type id: string
-    :param name: the name of the new metadata model (optional - auto-generated if not supplied);
+    :param name: the name of the new metadata schema (optional - auto-generated if not supplied);
         must conform to standard naming rules
     :type name: string
-    :param title: the title of the metadata model (optional)
+    :param title: the title of the metadata schema (optional)
     :type title: string
-    :param description: the description of the metadata model (optional)
+    :param description: the description of the metadata schema (optional)
     :type description: string
-    :param metadata_standard_id: the id or name of the metadata standard from which this model is derived
+    :param metadata_standard_id: the id or name of the metadata standard for which this schema is defined
     :type metadata_standard_id: string
-    :param model_json: the JSON dictionary defining the model (nullable)
-    :type model_json: string
+    :param schema_json: the JSON dictionary defining the schema (nullable)
+    :type schema_json: string
     :param organization_id: the id or name of the associated organization (nullable)
     :type organization_id: string
     :param infrastructure_id: the id or name of the associated infrastructure (nullable)
     :type infrastructure_id: string
 
-    :returns: the newly created metadata model (unless 'return_id_only' is set to True
-              in the context, in which case just the metadata model id will be returned)
+    :returns: the newly created metadata schema (unless 'return_id_only' is set to True
+              in the context, in which case just the metadata schema id will be returned)
     :rtype: dictionary
     """
-    log.info("Creating metadata model: %r", data_dict)
-    tk.check_access('metadata_model_create', context, data_dict)
+    log.info("Creating metadata schema: %r", data_dict)
+    tk.check_access('metadata_schema_create', context, data_dict)
 
     model = context['model']
     user = context['user']
@@ -116,12 +116,12 @@ def metadata_model_create(context, data_dict):
     defer_commit = context.get('defer_commit', False)
     return_id_only = context.get('return_id_only', False)
 
-    data, errors = tk.navl_validate(data_dict, schema.metadata_model_create_schema(), context)
+    data, errors = tk.navl_validate(data_dict, schema.metadata_schema_create_schema(), context)
     if errors:
         session.rollback()
         raise tk.ValidationError(errors)
 
-    metadata_model = model_save.metadata_model_dict_save(data, context)
+    metadata_schema = model_save.metadata_schema_dict_save(data, context)
 
     # creating the revision also flushes the session which gives us the new object id
     rev = model.repo.new_revision()
@@ -129,14 +129,14 @@ def metadata_model_create(context, data_dict):
     if 'message' in context:
         rev.message = context['message']
     else:
-        rev.message = _(u'REST API: Create metadata model %s') % metadata_model.id
+        rev.message = _(u'REST API: Create metadata schema %s') % metadata_schema.id
 
-    dependent_record_list = tk.get_action('metadata_model_dependent_record_list')(context, {'id': metadata_model.id})
+    dependent_record_list = tk.get_action('metadata_schema_dependent_record_list')(context, {'id': metadata_schema.id})
     invalidate_context = context.copy()
     invalidate_context.update({
         'defer_commit': True,
-        'trigger_action': 'metadata_model_create',
-        'trigger_object_id': metadata_model.id,
+        'trigger_action': 'metadata_schema_create',
+        'trigger_object_id': metadata_schema.id,
     })
     for metadata_record_id in dependent_record_list:
         tk.get_action('metadata_record_invalidate')(invalidate_context, {'id': metadata_record_id})
@@ -144,8 +144,8 @@ def metadata_model_create(context, data_dict):
     if not defer_commit:
         model.repo.commit()
 
-    output = metadata_model.id if return_id_only \
-        else tk.get_action('metadata_model_show')(context, {'id': metadata_model.id})
+    output = metadata_schema.id if return_id_only \
+        else tk.get_action('metadata_schema_show')(context, {'id': metadata_schema.id})
     return output
 
 
diff --git a/ckanext/metadata/logic/action/delete.py b/ckanext/metadata/logic/action/delete.py
index 31269e5..5810ba2 100644
--- a/ckanext/metadata/logic/action/delete.py
+++ b/ckanext/metadata/logic/action/delete.py
@@ -63,13 +63,13 @@ def metadata_standard_delete(context, data_dict):
         child_standard_dict['parent_standard_id'] = ''
         tk.get_action('metadata_standard_update')(cascade_context, child_standard_dict)
 
-    # cascade delete to dependent metadata models
-    metadata_model_ids = session.query(ckanext_model.MetadataModel.id) \
-        .filter(ckanext_model.MetadataModel.metadata_standard_id == metadata_standard_id) \
-        .filter(ckanext_model.MetadataModel.state != 'deleted') \
+    # cascade delete to dependent metadata schemas
+    metadata_schema_ids = session.query(ckanext_model.MetadataSchema.id) \
+        .filter(ckanext_model.MetadataSchema.metadata_standard_id == metadata_standard_id) \
+        .filter(ckanext_model.MetadataSchema.state != 'deleted') \
         .all()
-    for (metadata_model_id,) in metadata_model_ids:
-        tk.get_action('metadata_model_delete')(cascade_context, {'id': metadata_model_id})
+    for (metadata_schema_id,) in metadata_schema_ids:
+        tk.get_action('metadata_schema_delete')(cascade_context, {'id': metadata_schema_id})
 
     rev = model.repo.new_revision()
     rev.author = user
@@ -80,47 +80,47 @@ def metadata_standard_delete(context, data_dict):
         model.repo.commit()
 
 
-def metadata_model_delete(context, data_dict):
+def metadata_schema_delete(context, data_dict):
     """
-    Delete a metadata model.
+    Delete a metadata schema.
 
-    You must be authorized to delete the metadata model.
+    You must be authorized to delete the metadata schema.
 
-    Any metadata records that were dependent on this model are invalidated.
+    Any metadata records that were dependent on this schema are invalidated.
 
-    :param id: the id or name of the metadata model to delete
+    :param id: the id or name of the metadata schema to delete
     :type id: string
     """
-    log.info("Deleting metadata model: %r", data_dict)
+    log.info("Deleting metadata schema: %r", data_dict)
 
     model = context['model']
     user = context['user']
     defer_commit = context.get('defer_commit', False)
 
-    metadata_model_id = tk.get_or_bust(data_dict, 'id')
-    metadata_model = ckanext_model.MetadataModel.get(metadata_model_id)
-    if metadata_model is not None:
-        metadata_model_id = metadata_model.id
+    metadata_schema_id = tk.get_or_bust(data_dict, 'id')
+    metadata_schema = ckanext_model.MetadataSchema.get(metadata_schema_id)
+    if metadata_schema is not None:
+        metadata_schema_id = metadata_schema.id
     else:
-        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Model')))
+        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Schema')))
 
-    tk.check_access('metadata_model_delete', context, data_dict)
+    tk.check_access('metadata_schema_delete', context, data_dict)
 
     rev = model.repo.new_revision()
     rev.author = user
-    rev.message = _(u'REST API: Delete metadata model %s') % metadata_model_id
+    rev.message = _(u'REST API: Delete metadata schema %s') % metadata_schema_id
 
-    dependent_record_list = tk.get_action('metadata_model_dependent_record_list')(context, {'id': metadata_model_id})
+    dependent_record_list = tk.get_action('metadata_schema_dependent_record_list')(context, {'id': metadata_schema_id})
     invalidate_context = context.copy()
     invalidate_context.update({
         'defer_commit': True,
-        'trigger_action': 'metadata_model_delete',
-        'trigger_object_id': metadata_model_id,
+        'trigger_action': 'metadata_schema_delete',
+        'trigger_object_id': metadata_schema_id,
     })
     for metadata_record_id in dependent_record_list:
         tk.get_action('metadata_record_invalidate')(invalidate_context, {'id': metadata_record_id})
 
-    metadata_model.delete()
+    metadata_schema.delete()
     if not defer_commit:
         model.repo.commit()
 
@@ -159,19 +159,19 @@ def infrastructure_delete(context, data_dict):
             .count() > 0:
         raise tk.ValidationError(_('Infrastructure has dependent metadata records'))
 
-    # cascade delete to dependent metadata models
+    # cascade delete to dependent metadata schemas
     cascade_context = {
         'model': model,
         'user': user,
         'session': session,
         'defer_commit': True,
     }
-    metadata_model_ids = session.query(ckanext_model.MetadataModel.id) \
-        .filter(ckanext_model.MetadataModel.infrastructure_id == infrastructure_id) \
-        .filter(ckanext_model.MetadataModel.state != 'deleted') \
+    metadata_schema_ids = session.query(ckanext_model.MetadataSchema.id) \
+        .filter(ckanext_model.MetadataSchema.infrastructure_id == infrastructure_id) \
+        .filter(ckanext_model.MetadataSchema.state != 'deleted') \
         .all()
-    for (metadata_model_id,) in metadata_model_ids:
-        tk.get_action('metadata_model_delete')(cascade_context, {'id': metadata_model_id})
+    for (metadata_schema_id,) in metadata_schema_ids:
+        tk.get_action('metadata_schema_delete')(cascade_context, {'id': metadata_schema_id})
 
     data_dict['type'] = 'infrastructure'
     context['invoked_api'] = 'infrastructure_delete'
@@ -400,13 +400,13 @@ def organization_delete(context, data_dict):
     for (metadata_collection_id,) in metadata_collection_ids:
         tk.get_action('metadata_collection_delete')(cascade_context, {'id': metadata_collection_id})
 
-    # cascade delete to dependent metadata models
-    metadata_model_ids = session.query(ckanext_model.MetadataModel.id) \
-        .filter(ckanext_model.MetadataModel.organization_id == organization_id) \
-        .filter(ckanext_model.MetadataModel.state != 'deleted') \
+    # cascade delete to dependent metadata schemas
+    metadata_schema_ids = session.query(ckanext_model.MetadataSchema.id) \
+        .filter(ckanext_model.MetadataSchema.organization_id == organization_id) \
+        .filter(ckanext_model.MetadataSchema.state != 'deleted') \
         .all()
-    for (metadata_model_id,) in metadata_model_ids:
-        tk.get_action('metadata_model_delete')(cascade_context, {'id': metadata_model_id})
+    for (metadata_schema_id,) in metadata_schema_ids:
+        tk.get_action('metadata_schema_delete')(cascade_context, {'id': metadata_schema_id})
 
     # delete membership relations
     for member in session.query(model.Member) \
diff --git a/ckanext/metadata/logic/action/get.py b/ckanext/metadata/logic/action/get.py
index 120a9d0..059cb04 100644
--- a/ckanext/metadata/logic/action/get.py
+++ b/ckanext/metadata/logic/action/get.py
@@ -75,57 +75,57 @@ def metadata_standard_list(context, data_dict):
 
 
 @tk.side_effect_free
-def metadata_model_show(context, data_dict):
+def metadata_schema_show(context, data_dict):
     """
-    Return the details of a metadata model.
+    Return the details of a metadata schema.
 
-    :param id: the id or name of the metadata model
+    :param id: the id or name of the metadata schema
     :type id: string
 
     :rtype: dictionary
     """
-    log.debug("Retrieving metadata model: %r", data_dict)
+    log.debug("Retrieving metadata schema: %r", data_dict)
 
-    metadata_model_id = tk.get_or_bust(data_dict, 'id')
-    metadata_model = ckanext_model.MetadataModel.get(metadata_model_id)
-    if metadata_model is not None:
-        metadata_model_id = metadata_model.id
+    metadata_schema_id = tk.get_or_bust(data_dict, 'id')
+    metadata_schema = ckanext_model.MetadataSchema.get(metadata_schema_id)
+    if metadata_schema is not None:
+        metadata_schema_id = metadata_schema.id
     else:
-        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Model')))
+        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Schema')))
 
-    tk.check_access('metadata_model_show', context, data_dict)
+    tk.check_access('metadata_schema_show', context, data_dict)
 
-    context['metadata_model'] = metadata_model
-    metadata_model_dict = model_dictize.metadata_model_dictize(metadata_model, context)
+    context['metadata_schema'] = metadata_schema
+    metadata_schema_dict = model_dictize.metadata_schema_dictize(metadata_schema, context)
 
-    result_dict, errors = tk.navl_validate(metadata_model_dict, schema.metadata_model_show_schema(), context)
+    result_dict, errors = tk.navl_validate(metadata_schema_dict, schema.metadata_schema_show_schema(), context)
     return result_dict
 
 
 @tk.side_effect_free
-def metadata_model_list(context, data_dict):
+def metadata_schema_list(context, data_dict):
     """
-    Return a list of names of the site's metadata models.
+    Return a list of names of the site's metadata schemas.
 
     :param all_fields: return dictionaries instead of just names (optional, default: ``False``)
     :type all_fields: boolean
 
     :rtype: list of strings
     """
-    log.debug("Retrieving metadata model list: %r", data_dict)
-    tk.check_access('metadata_model_list', context, data_dict)
+    log.debug("Retrieving metadata schema list: %r", data_dict)
+    tk.check_access('metadata_schema_list', context, data_dict)
 
     session = context['session']
     all_fields = asbool(data_dict.get('all_fields'))
 
-    metadata_models = session.query(ckanext_model.MetadataModel.id, ckanext_model.MetadataModel.name) \
+    metadata_schemas = session.query(ckanext_model.MetadataSchema.id, ckanext_model.MetadataSchema.name) \
         .filter_by(state='active') \
         .all()
     result = []
-    for (id_, name) in metadata_models:
+    for (id_, name) in metadata_schemas:
         if all_fields:
             data_dict['id'] = id_
-            result += [tk.get_action('metadata_model_show')(context, data_dict)]
+            result += [tk.get_action('metadata_schema_show')(context, data_dict)]
         else:
             result += [name]
 
@@ -133,47 +133,47 @@ def metadata_model_list(context, data_dict):
 
 
 @tk.side_effect_free
-def metadata_model_dependent_record_list(context, data_dict):
+def metadata_schema_dependent_record_list(context, data_dict):
     """
     Return a list of ids of metadata records that are dependent on the given
-    metadata model for validation.
+    metadata schema for validation.
 
-    :param id: the id or name of the metadata model
+    :param id: the id or name of the metadata schema
     :type id: string
 
     :rtype: list of strings
     """
-    log.debug("Retrieving list of metadata records dependent on metadata model: %r", data_dict)
+    log.debug("Retrieving list of metadata records dependent on metadata schema: %r", data_dict)
 
     session = context['session']
     model = context['model']
 
-    metadata_model_id = tk.get_or_bust(data_dict, 'id')
-    metadata_model = ckanext_model.MetadataModel.get(metadata_model_id)
-    if metadata_model is not None:
-        metadata_model_id = metadata_model.id
+    metadata_schema_id = tk.get_or_bust(data_dict, 'id')
+    metadata_schema = ckanext_model.MetadataSchema.get(metadata_schema_id)
+    if metadata_schema is not None:
+        metadata_schema_id = metadata_schema.id
     else:
-        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Model')))
+        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Schema')))
 
-    tk.check_access('metadata_model_dependent_record_list', context, data_dict)
+    tk.check_access('metadata_schema_dependent_record_list', context, data_dict)
 
     q = session.query(model.Package.id) \
         .join(model.PackageExtra) \
         .filter(model.Package.state == 'active') \
         .filter(model.PackageExtra.key == 'metadata_standard_id') \
-        .filter(model.PackageExtra.value == metadata_model.metadata_standard_id)
+        .filter(model.PackageExtra.value == metadata_schema.metadata_standard_id)
 
-    if metadata_model.organization_id:
-        q = q.filter(model.Package.owner_org == metadata_model.organization_id)
+    if metadata_schema.organization_id:
+        q = q.filter(model.Package.owner_org == metadata_schema.organization_id)
 
-    if metadata_model.infrastructure_id:
+    if metadata_schema.infrastructure_id:
         q = q.join(model.Member, model.Member.table_id == model.Package.id) \
             .filter(model.Member.table_name == 'package') \
             .filter(model.Member.state == 'active') \
             .join(model.Group, model.Group.id == model.Member.group_id) \
             .filter(model.Group.type == 'infrastructure') \
             .filter(model.Group.state == 'active') \
-            .filter(model.Group.id == metadata_model.infrastructure_id)
+            .filter(model.Group.id == metadata_schema.infrastructure_id)
 
     return [metadata_record_id for (metadata_record_id,) in q.all()]
 
@@ -441,23 +441,23 @@ def metadata_record_list(context, data_dict):
 
 
 @tk.side_effect_free
-def metadata_record_validation_model_list(context, data_dict):
+def metadata_record_validation_schema_list(context, data_dict):
     """
-    Return a list of metadata models to be used for validating a metadata record.
+    Return a list of metadata schemas to be used for validating a metadata record.
 
     This comprises the following:
-    1. The default model defined for the record's metadata standard.
-    2. A model for that standard (optionally) defined for the owner organization.
-    3. Any models (optionally) defined for that standard for infrastructures linked to the record.
+    1. The default schema defined for the record's metadata standard.
+    2. A schema for that standard (optionally) defined for the owner organization.
+    3. Any schemas (optionally) defined for that standard for infrastructures linked to the record.
 
     :param id: the id or name of the metadata record
     :type id: string
     :param all_fields: return dictionaries instead of just names (optional, default: ``False``)
     :type all_fields: boolean
 
-    :rtype: list of names (dictionaries if all_fields) of metadata models
+    :rtype: list of names (dictionaries if all_fields) of metadata schemas
     """
-    log.debug("Retrieving metadata models for metadata record validation: %r", data_dict)
+    log.debug("Retrieving metadata schemas for metadata record validation: %r", data_dict)
 
     model = context['model']
     session = context['session']
@@ -473,7 +473,7 @@ def metadata_record_validation_model_list(context, data_dict):
         else:
             raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Record')))
 
-    tk.check_access('metadata_record_validation_model_list', context, data_dict)
+    tk.check_access('metadata_record_validation_schema_list', context, data_dict)
 
     organization_id = metadata_record.owner_org
     infrastructure_ids = session.query(model.Group.id) \
@@ -488,20 +488,20 @@ def metadata_record_validation_model_list(context, data_dict):
     metadata_standard_id = session.query(model.PackageExtra.value) \
         .filter_by(package_id=metadata_record_id, key='metadata_standard_id').scalar()
 
-    MetadataModel = ckanext_model.MetadataModel
-    metadata_model_names = session.query(MetadataModel.name) \
+    MetadataSchema = ckanext_model.MetadataSchema
+    metadata_schema_names = session.query(MetadataSchema.name) \
         .filter_by(metadata_standard_id=metadata_standard_id, state='active') \
-        .filter(or_(MetadataModel.organization_id == organization_id, MetadataModel.organization_id == None)) \
-        .filter(or_(MetadataModel.infrastructure_id == infra_id for infra_id in infrastructure_ids)) \
+        .filter(or_(MetadataSchema.organization_id == organization_id, MetadataSchema.organization_id == None)) \
+        .filter(or_(MetadataSchema.infrastructure_id == infra_id for infra_id in infrastructure_ids)) \
         .all()
 
     result = []
     all_fields = asbool(data_dict.get('all_fields'))
-    for (metadata_model_name,) in metadata_model_names:
+    for (metadata_schema_name,) in metadata_schema_names:
         if all_fields:
-            result += [tk.get_action('metadata_model_show')(context, {'id': metadata_model_name})]
+            result += [tk.get_action('metadata_schema_show')(context, {'id': metadata_schema_name})]
         else:
-            result += [metadata_model_name]
+            result += [metadata_schema_name]
 
     return result
 
@@ -547,15 +547,15 @@ def metadata_record_validation_activity_show(context, data_dict):
 @tk.side_effect_free
 def metadata_validity_check(context, data_dict):
     """
-    Check the validity of a metadata dictionary against a metadata model.
+    Check the validity of a metadata dictionary against a metadata schema.
 
     :param metadata_json: JSON dictionary of metadata record content
     :type metadata_json: string
-    :param model_json: JSON dictionary defining a metadata model
-    :type model_json: string
+    :param schema_json: JSON dictionary defining a metadata schema
+    :type schema_json: string
 
     :rtype: dictionary of metadata errors; empty dict implies that the metadata is 100% valid
-        against the given model
+        against the given schema
     """
     log.debug("Checking metadata validity")
     tk.check_access('metadata_validity_check', context, data_dict)
@@ -567,9 +567,9 @@ def metadata_validity_check(context, data_dict):
         raise tk.ValidationError(errors)
 
     metadata_json = json.loads(data['metadata_json'])
-    model_json = json.loads(data['model_json'])
+    schema_json = json.loads(data['schema_json'])
 
-    metadata_errors = MetadataValidator(model_json).validate(metadata_json)
+    metadata_errors = MetadataValidator(schema_json).validate(metadata_json)
     return metadata_errors
 
 
diff --git a/ckanext/metadata/logic/action/update.py b/ckanext/metadata/logic/action/update.py
index 9a5c0e8..4d805c5 100644
--- a/ckanext/metadata/logic/action/update.py
+++ b/ckanext/metadata/logic/action/update.py
@@ -101,31 +101,31 @@ def metadata_standard_update(context, data_dict):
     return output
 
 
-def metadata_model_update(context, data_dict):
+def metadata_schema_update(context, data_dict):
     """
-    Update a metadata model.
+    Update a metadata schema.
 
-    You must be authorized to edit the metadata model.
+    You must be authorized to edit the metadata schema.
 
-    Changes to the model_json will cause dependent metadata records to be invalidated.
+    Changes to the schema_json will cause dependent metadata records to be invalidated.
     If any of metadata_standard_id, organization_id or infrastructure_id change, then
     ex-dependent and newly-dependent metadata records will also be invalidated.
 
     It is recommended to call
-    :py:func:`ckan.logic.action.get.metadata_model_show`, make the desired changes to
-    the result, and then call ``metadata_model_update()`` with it.
+    :py:func:`ckan.logic.action.get.metadata_schema_show`, make the desired changes to
+    the result, and then call ``metadata_schema_update()`` with it.
 
     For further parameters see
-    :py:func:`~ckanext.metadata.logic.action.create.metadata_model_create`.
+    :py:func:`~ckanext.metadata.logic.action.create.metadata_schema_create`.
 
-    :param id: the id or name of the metadata model to update
+    :param id: the id or name of the metadata schema to update
     :type id: string
 
-    :returns: the updated metadata model (unless 'return_id_only' is set to True
-              in the context, in which case just the metadata model id will be returned)
+    :returns: the updated metadata schema (unless 'return_id_only' is set to True
+              in the context, in which case just the metadata schema id will be returned)
     :rtype: dictionary
     """
-    log.info("Updating metadata model: %r", data_dict)
+    log.info("Updating metadata schema: %r", data_dict)
 
     model = context['model']
     user = context['user']
@@ -133,40 +133,40 @@ def metadata_model_update(context, data_dict):
     defer_commit = context.get('defer_commit', False)
     return_id_only = context.get('return_id_only', False)
 
-    metadata_model_id = tk.get_or_bust(data_dict, 'id')
-    metadata_model = ckanext_model.MetadataModel.get(metadata_model_id)
-    if metadata_model is not None:
-        metadata_model_id = metadata_model.id
+    metadata_schema_id = tk.get_or_bust(data_dict, 'id')
+    metadata_schema = ckanext_model.MetadataSchema.get(metadata_schema_id)
+    if metadata_schema is not None:
+        metadata_schema_id = metadata_schema.id
     else:
-        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Model')))
+        raise tk.ObjectNotFound('%s: %s' % (_('Not found'), _('Metadata Schema')))
 
-    tk.check_access('metadata_model_update', context, data_dict)
+    tk.check_access('metadata_schema_update', context, data_dict)
 
-    old_model_json = metadata_model.model_json
-    if old_model_json:
-        old_model_json = json.loads(old_model_json)
-    old_dependent_record_list = tk.get_action('metadata_model_dependent_record_list')(context, {'id': metadata_model_id})
+    old_schema_json = metadata_schema.schema_json
+    if old_schema_json:
+        old_schema_json = json.loads(old_schema_json)
+    old_dependent_record_list = tk.get_action('metadata_schema_dependent_record_list')(context, {'id': metadata_schema_id})
 
     data_dict.update({
-        'id': metadata_model_id,
+        'id': metadata_schema_id,
     })
     context.update({
-        'metadata_model': metadata_model,
+        'metadata_schema': metadata_schema,
         'allow_partial_update': True,
     })
 
-    data, errors = tk.navl_validate(data_dict, schema.metadata_model_update_schema(), context)
+    data, errors = tk.navl_validate(data_dict, schema.metadata_schema_update_schema(), context)
     if errors:
         session.rollback()
         raise tk.ValidationError(errors)
 
-    metadata_model = model_save.metadata_model_dict_save(data, context)
-    new_model_json = metadata_model.model_json
-    if new_model_json:
-        new_model_json = json.loads(new_model_json)
-    new_dependent_record_list = tk.get_action('metadata_model_dependent_record_list')(context, {'id': metadata_model_id})
+    metadata_schema = model_save.metadata_schema_dict_save(data, context)
+    new_schema_json = metadata_schema.schema_json
+    if new_schema_json:
+        new_schema_json = json.loads(new_schema_json)
+    new_dependent_record_list = tk.get_action('metadata_schema_dependent_record_list')(context, {'id': metadata_schema_id})
 
-    if old_model_json != new_model_json:
+    if old_schema_json != new_schema_json:
         affected_record_ids = set(old_dependent_record_list) | set(new_dependent_record_list)
     else:
         affected_record_ids = set(old_dependent_record_list) ^ set(new_dependent_record_list)
@@ -176,13 +176,13 @@ def metadata_model_update(context, data_dict):
     if 'message' in context:
         rev.message = context['message']
     else:
-        rev.message = _(u'REST API: Update metadata model %s') % metadata_model_id
+        rev.message = _(u'REST API: Update metadata schema %s') % metadata_schema_id
 
     invalidate_context = context.copy()
     invalidate_context.update({
         'defer_commit': True,
-        'trigger_action': 'metadata_model_update',
-        'trigger_object_id': metadata_model_id,
+        'trigger_action': 'metadata_schema_update',
+        'trigger_object_id': metadata_schema_id,
     })
     for metadata_record_id in affected_record_ids:
         tk.get_action('metadata_record_invalidate')(invalidate_context, {'id': metadata_record_id})
@@ -190,8 +190,8 @@ def metadata_model_update(context, data_dict):
     if not defer_commit:
         model.repo.commit()
 
-    output = metadata_model_id if return_id_only \
-        else tk.get_action('metadata_model_show')(context, {'id': metadata_model_id})
+    output = metadata_schema_id if return_id_only \
+        else tk.get_action('metadata_schema_show')(context, {'id': metadata_schema_id})
     return output
 
 
@@ -358,7 +358,7 @@ def metadata_record_update(context, data_dict):
         old_metadata_json = metadata_record.extras['metadata_json']
         if old_metadata_json:
             old_metadata_json = json.loads(old_metadata_json)
-        old_validation_models = set(tk.get_action('metadata_record_validation_model_list')(context, {'id': metadata_record_id}))
+        old_validation_schemas = set(tk.get_action('metadata_record_validation_schema_list')(context, {'id': metadata_record_id}))
 
     data_dict.update({
         'id': metadata_record_id,
@@ -381,17 +381,17 @@ def metadata_record_update(context, data_dict):
 
     # check if we need to invalidate the record
     if asbool(metadata_record.extras['validated']):
-        # ensure new validation model list sees infrastructure list changes
+        # ensure new validation schema list sees infrastructure list changes
         session.flush()
 
         new_metadata_json = metadata_record.extras['metadata_json']
         if new_metadata_json:
             new_metadata_json = json.loads(new_metadata_json)
-        new_validation_models = set(tk.get_action('metadata_record_validation_model_list')(context, {'id': metadata_record_id}))
+        new_validation_schemas = set(tk.get_action('metadata_record_validation_schema_list')(context, {'id': metadata_record_id}))
 
-        # if either the metadata record content or the set of validation models for the record has changed,
+        # if either the metadata record content or the set of validation schemas for the record has changed,
         # then the record must be invalidated
-        if old_metadata_json != new_metadata_json or old_validation_models != new_validation_models:
+        if old_metadata_json != new_metadata_json or old_validation_schemas != new_validation_schemas:
             invalidate_context = context.copy()
             invalidate_context.update({
                 'defer_commit': True,
@@ -418,8 +418,8 @@ def metadata_record_invalidate(context, data_dict):
     Note: this function is typically called from within another action function
     whose effect triggers invalidation of the given metadata record. In such a
     case, the calling function should pass the following items in the context:
-    'trigger_action': the calling function name, e.g. 'metadata_model_update'
-    'trigger_object_id': the id of the object (e.g. a MetadataModel) being modified
+    'trigger_action': the calling function name, e.g. 'metadata_schema_update'
+    'trigger_object_id': the id of the object (e.g. a MetadataSchema) being modified
 
     :param id: the id or name of the metadata record to invalidate
     :type id: string
@@ -525,23 +525,23 @@ def metadata_record_validate(context, data_dict):
     if asbool(metadata_record.extras['validated']):
         return
 
-    validation_models = tk.get_action('metadata_record_validation_model_list')(context, {
+    validation_schemas = tk.get_action('metadata_record_validation_schema_list')(context, {
         'id': metadata_record_id,
         'all_fields': True,
     })
-    if not validation_models:
-        raise tk.ObjectNotFound(_('Could not find any metadata models for validating this metadata record'))
+    if not validation_schemas:
+        raise tk.ObjectNotFound(_('Could not find any metadata schemas for validating this metadata record'))
 
     # delegate the actual validation work to the pluggable action metadata_validity_check
     validation_results = []
     accumulated_errors = {}
-    for metadata_model in validation_models:
+    for metadata_schema in validation_schemas:
         validation_errors = tk.get_action('metadata_validity_check')(context, {
             'metadata_json': metadata_record.extras['metadata_json'],
-            'model_json': json.dumps(metadata_model['model_json']),
+            'schema_json': json.dumps(metadata_schema['schema_json']),
         })
         validation_result = {
-            'metadata_model_id': metadata_model['id'],
+            'metadata_schema_id': metadata_schema['id'],
             'errors': validation_errors,
         }
         validation_results += [validation_result]
diff --git a/ckanext/metadata/logic/auth/create.py b/ckanext/metadata/logic/auth/create.py
index 6c766a8..504d91e 100644
--- a/ckanext/metadata/logic/auth/create.py
+++ b/ckanext/metadata/logic/auth/create.py
@@ -33,7 +33,7 @@ def metadata_standard_create(context, data_dict):
     return {'success': True}
 
 
-def metadata_model_create(context, data_dict):
+def metadata_schema_create(context, data_dict):
     return {'success': True}
 
 
diff --git a/ckanext/metadata/logic/auth/delete.py b/ckanext/metadata/logic/auth/delete.py
index b420cdf..05b7c6d 100644
--- a/ckanext/metadata/logic/auth/delete.py
+++ b/ckanext/metadata/logic/auth/delete.py
@@ -33,7 +33,7 @@ def metadata_standard_delete(context, data_dict):
     return {'success': True}
 
 
-def metadata_model_delete(context, data_dict):
+def metadata_schema_delete(context, data_dict):
     return {'success': True}
 
 
diff --git a/ckanext/metadata/logic/auth/get.py b/ckanext/metadata/logic/auth/get.py
index ed65f79..a60f519 100644
--- a/ckanext/metadata/logic/auth/get.py
+++ b/ckanext/metadata/logic/auth/get.py
@@ -53,7 +53,7 @@ def metadata_standard_show(context, data_dict):
     return {'success': True}
 
 
-def metadata_model_show(context, data_dict):
+def metadata_schema_show(context, data_dict):
     return {'success': True}
 
 
@@ -73,11 +73,11 @@ def metadata_standard_list(context, data_dict):
     return {'success': True}
 
 
-def metadata_model_list(context, data_dict):
+def metadata_schema_list(context, data_dict):
     return {'success': True}
 
 
-def metadata_model_dependent_record_list(context, data_dict):
+def metadata_schema_dependent_record_list(context, data_dict):
     return {'success': True}
 
 
@@ -93,7 +93,7 @@ def metadata_record_list(context, data_dict):
     return {'success': True}
 
 
-def metadata_record_validation_model_list(context, data_dict):
+def metadata_record_validation_schema_list(context, data_dict):
     return {'success': True}
 
 
diff --git a/ckanext/metadata/logic/auth/update.py b/ckanext/metadata/logic/auth/update.py
index 0321a96..3f70703 100644
--- a/ckanext/metadata/logic/auth/update.py
+++ b/ckanext/metadata/logic/auth/update.py
@@ -33,7 +33,7 @@ def metadata_standard_update(context, data_dict):
     return {'success': True}
 
 
-def metadata_model_update(context, data_dict):
+def metadata_schema_update(context, data_dict):
     return {'success': True}
 
 
diff --git a/ckanext/metadata/logic/schema.py b/ckanext/metadata/logic/schema.py
index 7b93b39..8fcaf17 100644
--- a/ckanext/metadata/logic/schema.py
+++ b/ckanext/metadata/logic/schema.py
@@ -142,7 +142,7 @@ def metadata_record_show_schema():
 def metadata_validity_check_schema():
     schema = {
         'metadata_json': [v.not_empty, unicode, v.json_dict_validator],
-        'model_json': [v.not_empty, unicode, v.json_schema_validator],
+        'schema_json': [v.not_empty, unicode, v.json_schema_validator],
     }
     return schema
 
@@ -272,39 +272,39 @@ def metadata_standard_show_schema():
     return schema
 
 
-def metadata_model_create_schema():
+def metadata_schema_create_schema():
     schema = {
-        'id': [empty_if_not_sysadmin, ignore_missing, unicode, v.object_does_not_exist('metadata_model')],
-        'name': [ignore_missing, unicode, name_validator, v.object_name_validator('metadata_model')],
+        'id': [empty_if_not_sysadmin, ignore_missing, unicode, v.object_does_not_exist('metadata_schema')],
+        'name': [ignore_missing, unicode, name_validator, v.object_name_validator('metadata_schema')],
         'title': [ignore_missing, unicode],
         'description': [ignore_missing, unicode],
         'metadata_standard_id': [v.not_empty, unicode, v.object_exists('metadata_standard')],
         'organization_id': [v.not_missing, unicode, v.object_exists('organization')],
         'infrastructure_id': [v.not_missing, unicode, v.object_exists('infrastructure')],
-        'model_json': [v.not_empty, unicode, v.json_schema_validator],
+        'schema_json': [v.not_empty, unicode, v.json_schema_validator],
         'state': [ignore_not_sysadmin, ignore_missing],
 
         # post-validation
-        '__after': [v.metadata_model_name_generator,
-                    v.metadata_model_check_organization_infrastructure,
-                    v.metadata_model_unique_standard_organization_infrastructure,
+        '__after': [v.metadata_schema_name_generator,
+                    v.metadata_schema_check_organization_infrastructure,
+                    v.metadata_schema_unique_standard_organization_infrastructure,
                     ignore],
     }
     _make_create_schema(schema)
     return schema
 
 
-def metadata_model_update_schema():
-    schema = metadata_model_create_schema()
+def metadata_schema_update_schema():
+    schema = metadata_schema_create_schema()
     _make_update_schema(schema)
     return schema
 
 
-def metadata_model_show_schema():
-    schema = metadata_model_create_schema()
+def metadata_schema_show_schema():
+    schema = metadata_schema_create_schema()
     _make_show_schema(schema)
     schema.update({
-        'model_json': [v.deserialize_json],
+        'schema_json': [v.deserialize_json],
         'metadata_standard_id': [v.convert_id_to_name('metadata_standard')],
         'organization_id': [v.convert_id_to_name('organization')],
         'infrastructure_id': [v.convert_id_to_name('infrastructure')],
diff --git a/ckanext/metadata/logic/validators.py b/ckanext/metadata/logic/validators.py
index e1e39de..0004a41 100644
--- a/ckanext/metadata/logic/validators.py
+++ b/ckanext/metadata/logic/validators.py
@@ -385,9 +385,9 @@ def no_loops_in_metadata_standard_hierarchy(key, data, errors, context):
             if parent.parent_standard_id is not None else None
 
 
-def metadata_model_unique_standard_organization_infrastructure(key, data, errors, context):
+def metadata_schema_unique_standard_organization_infrastructure(key, data, errors, context):
     """
-    Checks the uniqueness of metadata_standard-organization-infrastructure for a metadata model.
+    Checks the uniqueness of metadata_standard-organization-infrastructure for a metadata schema.
     For use with the '__after' schema key; group names should already have been converted to group ids.
     """
     metadata_standard_id = data.get(key[:-1] + ('metadata_standard_id',))
@@ -395,7 +395,7 @@ def metadata_model_unique_standard_organization_infrastructure(key, data, errors
     infrastructure_id = data.get(key[:-1] + ('infrastructure_id',))
 
     id_ = _convert_missing(data.get(key[:-1] + ('id',)))
-    obj = ckanext_model.MetadataModel.get(id_) if id_ else None
+    obj = ckanext_model.MetadataSchema.get(id_) if id_ else None
 
     # if we're updating, missing value(s) in the input data imply a partial update, so get the
     # existing value(s) and check that the updated key does not violate uniqueness
@@ -403,21 +403,21 @@ def metadata_model_unique_standard_organization_infrastructure(key, data, errors
     organization_id = _convert_missing(organization_id, obj.organization_id if obj else None)
     infrastructure_id = _convert_missing(infrastructure_id, obj.infrastructure_id if obj else None)
 
-    metadata_model = ckanext_model.MetadataModel.lookup(metadata_standard_id, organization_id, infrastructure_id)
-    if metadata_model and metadata_model.state != 'deleted' and metadata_model.id != id_:
+    metadata_schema = ckanext_model.MetadataSchema.lookup(metadata_standard_id, organization_id, infrastructure_id)
+    if metadata_schema and metadata_schema.state != 'deleted' and metadata_schema.id != id_:
         raise tk.Invalid(_("Unique constraint violation: %s") % '(metadata_standard_id, organization_id, infrastructure_id)')
 
 
-def metadata_model_check_organization_infrastructure(key, data, errors, context):
+def metadata_schema_check_organization_infrastructure(key, data, errors, context):
     """
-    Checks that only one of organization and infrastructure have been set for a metadata model.
+    Checks that only one of organization and infrastructure have been set for a metadata schema.
     For use with the '__after' schema key; group names should already have been converted to group ids.
     """
     organization_id = data.get(key[:-1] + ('organization_id',))
     infrastructure_id = data.get(key[:-1] + ('infrastructure_id',))
 
     id_ = _convert_missing(data.get(key[:-1] + ('id',)))
-    obj = ckanext_model.MetadataModel.get(id_) if id_ else None
+    obj = ckanext_model.MetadataSchema.get(id_) if id_ else None
 
     # if we're updating, missing value(s) in the input data imply a partial update, so get the
     # existing value(s) and check that the updated combination does not violate the check constraint
@@ -425,7 +425,7 @@ def metadata_model_check_organization_infrastructure(key, data, errors, context)
     infrastructure_id = _convert_missing(infrastructure_id, obj.infrastructure_id if obj else None)
 
     if organization_id and infrastructure_id:
-        raise tk.Invalid(_("A metadata model may be associated with either an organization or an "
+        raise tk.Invalid(_("A metadata schema may be associated with either an organization or an "
                            "infrastructure but not both."))
 
 
@@ -450,9 +450,9 @@ def metadata_standard_name_generator(key, data, errors, context):
         data[key[:-1] + ('name',)] = name
 
 
-def metadata_model_name_generator(key, data, errors, context):
+def metadata_schema_name_generator(key, data, errors, context):
     """
-    Generates the name for a metadata model if not supplied. For use with the '__after' schema key.
+    Generates the name for a metadata schema if not supplied. For use with the '__after' schema key.
     """
     model = context['model']
 
@@ -471,16 +471,16 @@ def get_name_components(metadata_standard_id, organization_id, infrastructure_id
     if not name:
         id_ = _convert_missing(data.get(key[:-1] + ('id',)))
         if id_:
-            metadata_model = ckanext_model.MetadataModel.get(id_)
-            if metadata_model:
+            metadata_schema = ckanext_model.MetadataSchema.get(id_)
+            if metadata_schema:
                 # for updates we want to re-generate the name only if it was previously auto-generated
                 metadata_standard_name, organization_name, infrastructure_name = get_name_components(
-                    metadata_model.metadata_standard_id,
-                    metadata_model.organization_id,
-                    metadata_model.infrastructure_id
+                    metadata_schema.metadata_standard_id,
+                    metadata_schema.organization_id,
+                    metadata_schema.infrastructure_id
                 )
                 autoname = _generate_name(metadata_standard_name, organization_name, infrastructure_name)
-                if metadata_model.name != autoname:
+                if metadata_schema.name != autoname:
                     return
 
         metadata_standard_name, organization_name, infrastructure_name = get_name_components(
diff --git a/ckanext/metadata/model/__init__.py b/ckanext/metadata/model/__init__.py
index 812af5e..0c9b668 100644
--- a/ckanext/metadata/model/__init__.py
+++ b/ckanext/metadata/model/__init__.py
@@ -7,11 +7,11 @@
     metadata_standard_revision_table,
 )
 
-from metadata_model import (
-    MetadataModel,
-    MetadataModelRevision,
-    metadata_model_table,
-    metadata_model_revision_table,
+from metadata_schema import (
+    MetadataSchema,
+    MetadataSchemaRevision,
+    metadata_schema_table,
+    metadata_schema_revision_table,
 )
 
 from workflow_state import (
diff --git a/ckanext/metadata/model/metadata_model.py b/ckanext/metadata/model/metadata_schema.py
similarity index 54%
rename from ckanext/metadata/model/metadata_model.py
rename to ckanext/metadata/model/metadata_schema.py
index 50974cc..4926c7e 100644
--- a/ckanext/metadata/model/metadata_model.py
+++ b/ckanext/metadata/model/metadata_schema.py
@@ -4,11 +4,10 @@
 import vdm.sqlalchemy
 
 from ckan.model import meta, core, types as _types, domain_object
-from ckanext.metadata.model.metadata_standard import MetadataStandard
 
 
-metadata_model_table = Table(
-    'metadata_model', meta.metadata,
+metadata_schema_table = Table(
+    'metadata_schema', meta.metadata,
     Column('id', types.UnicodeText, primary_key=True, default=_types.make_uuid),
     Column('name', types.UnicodeText, nullable=False, unique=True),
     Column('title', types.UnicodeText),
@@ -16,36 +15,36 @@
     Column('metadata_standard_id', types.UnicodeText, ForeignKey('metadata_standard.id'), nullable=False),
     Column('organization_id', types.UnicodeText, ForeignKey('group.id')),
     Column('infrastructure_id', types.UnicodeText, ForeignKey('group.id')),
-    Column('model_json', types.UnicodeText),
-    # null organization & infrastructure indicates the default model for the given metadata standard
+    Column('schema_json', types.UnicodeText),
+    # null organization & infrastructure implies that the object is the default schema for the given metadata standard
     UniqueConstraint('metadata_standard_id', 'organization_id', 'infrastructure_id')
 )
 
-vdm.sqlalchemy.make_table_stateful(metadata_model_table)
-metadata_model_revision_table = core.make_revisioned_table(metadata_model_table)
+vdm.sqlalchemy.make_table_stateful(metadata_schema_table)
+metadata_schema_revision_table = core.make_revisioned_table(metadata_schema_table)
 
 
-class MetadataModel(vdm.sqlalchemy.RevisionedObjectMixin,
+class MetadataSchema(vdm.sqlalchemy.RevisionedObjectMixin,
                     vdm.sqlalchemy.StatefulObjectMixin,
                     domain_object.DomainObject):
 
     @classmethod
     def get(cls, reference):
         """
-        Returns a metadata_model object referenced by its id or name.
+        Returns a metadata_schema object referenced by its id or name.
         """
         if not reference:
             return None
 
-        metadata_model = meta.Session.query(cls).get(reference)
-        if metadata_model is None:
-            metadata_model = cls.by_name(reference)
-        return metadata_model
+        metadata_schema = meta.Session.query(cls).get(reference)
+        if metadata_schema is None:
+            metadata_schema = cls.by_name(reference)
+        return metadata_schema
 
     @classmethod
     def lookup(cls, metadata_standard_id, organization_id, infrastructure_id):
         """
-        Returns a metadata_model object by metadata_standard, organization, infrastructure.
+        Returns a metadata_schema object by metadata_standard, organization, infrastructure.
         """
         return meta.Session.query(cls) \
             .filter(cls.metadata_standard_id == metadata_standard_id) \
@@ -54,9 +53,9 @@ def lookup(cls, metadata_standard_id, organization_id, infrastructure_id):
             .first()
 
 
-meta.mapper(MetadataModel, metadata_model_table,
-            extension=[vdm.sqlalchemy.Revisioner(metadata_model_revision_table)])
+meta.mapper(MetadataSchema, metadata_schema_table,
+            extension=[vdm.sqlalchemy.Revisioner(metadata_schema_revision_table)])
 
-vdm.sqlalchemy.modify_base_object_mapper(MetadataModel, core.Revision, core.State)
-MetadataModelRevision = vdm.sqlalchemy.create_object_version(
-    meta.mapper, MetadataModel, metadata_model_revision_table)
+vdm.sqlalchemy.modify_base_object_mapper(MetadataSchema, core.Revision, core.State)
+MetadataSchemaRevision = vdm.sqlalchemy.create_object_version(
+    meta.mapper, MetadataSchema, metadata_schema_revision_table)
diff --git a/ckanext/metadata/model/setup.py b/ckanext/metadata/model/setup.py
index 9cd44ca..29e14e9 100644
--- a/ckanext/metadata/model/setup.py
+++ b/ckanext/metadata/model/setup.py
@@ -11,8 +11,8 @@ def init_tables():
     tables = (
         metadata_standard_table,
         metadata_standard_revision_table,
-        metadata_model_table,
-        metadata_model_revision_table,
+        metadata_schema_table,
+        metadata_schema_revision_table,
         workflow_state_table,
         workflow_state_revision_table,
         workflow_transition_table,
diff --git a/ckanext/metadata/tests/__init__.py b/ckanext/metadata/tests/__init__.py
index 88fee13..8ce6683 100644
--- a/ckanext/metadata/tests/__init__.py
+++ b/ckanext/metadata/tests/__init__.py
@@ -23,7 +23,7 @@
     'infrastructure': ckan_model.Group,
     'metadata_collection': ckan_model.Group,
     'metadata_record': ckan_model.Package,
-    'metadata_model': ckanext_model.MetadataModel,
+    'metadata_schema': ckanext_model.MetadataSchema,
     'metadata_standard': ckanext_model.MetadataStandard,
     'workflow_state': ckanext_model.WorkflowState,
     'workflow_transition': ckanext_model.WorkflowTransition,
@@ -126,19 +126,19 @@ def assert_group_has_member(group_id, object_id, object_table, capacity='public'
     assert member.state == state
 
 
-def assert_metadata_record_has_validation_models(metadata_record_id, *metadata_model_names):
+def assert_metadata_record_has_validation_schemas(metadata_record_id, *metadata_schema_names):
     """
-    Check that the given record has the expected set of validation models.
+    Check that the given record has the expected set of validation schemas.
     """
-    validation_model_list = call_action('metadata_record_validation_model_list', id=metadata_record_id)
-    assert set(validation_model_list) == set(metadata_model_names)
+    validation_schema_list = call_action('metadata_record_validation_schema_list', id=metadata_record_id)
+    assert set(validation_schema_list) == set(metadata_schema_names)
 
 
-def assert_metadata_model_has_dependent_records(metadata_model_id, *metadata_record_ids):
+def assert_metadata_schema_has_dependent_records(metadata_schema_id, *metadata_record_ids):
     """
-    Check that the given model has the expected set of dependent records.
+    Check that the given schema has the expected set of dependent records.
     """
-    dependent_record_list = call_action('metadata_model_dependent_record_list', id=metadata_model_id)
+    dependent_record_list = call_action('metadata_schema_dependent_record_list', id=metadata_schema_id)
     assert set(dependent_record_list) == set(metadata_record_ids)
 
 
@@ -237,10 +237,10 @@ def test_action(self, action_name, should_error=False, exception_class=tk.Valida
 
         return result, obj
 
-    def assert_validate_activity_logged(self, metadata_record_id, *validation_models, **validation_errors):
+    def assert_validate_activity_logged(self, metadata_record_id, *validation_schemas, **validation_errors):
         """
-        :param validation_models: iterable of metadata model dictionaries
-        :param validation_errors: dictionary mapping metadata model keys to expected error patterns (regex's)
+        :param validation_schemas: iterable of metadata schema dictionaries
+        :param validation_errors: dictionary mapping metadata schema keys to expected error patterns (regex's)
         """
         activity_dict = call_action('metadata_record_validation_activity_show', id=metadata_record_id)
         assert activity_dict['user_id'] == self.normal_user['id']
@@ -248,11 +248,11 @@ def assert_validate_activity_logged(self, metadata_record_id, *validation_models
         assert activity_dict['activity_type'] == 'metadata validation'
         assert activity_dict['data']['action'] == 'metadata_record_validate'
         logged_results = activity_dict['data']['results']
-        assert len(logged_results) == len(validation_models)
+        assert len(logged_results) == len(validation_schemas)
         logged_errors = {}
-        for validation_model in validation_models:
+        for validation_schema in validation_schemas:
             logged_result = next((result for result in logged_results
-                                  if result['metadata_model_id'] == validation_model['id']), None)
+                                  if result['metadata_schema_id'] == validation_schema['id']), None)
             assert logged_result
             logged_errors.update(logged_result['errors'])
         assert len(logged_errors) == len(validation_errors)
diff --git a/ckanext/metadata/tests/factories.py b/ckanext/metadata/tests/factories.py
index f1e7f47..db563c0 100644
--- a/ckanext/metadata/tests/factories.py
+++ b/ckanext/metadata/tests/factories.py
@@ -89,12 +89,12 @@ def _create(cls, target_class, *args, **kwargs):
         return helpers.call_action('metadata_standard_create', context=context, **kwargs)
 
 
-class MetadataModel(factory.Factory):
-    FACTORY_FOR = ckanext_model.MetadataModel
+class MetadataSchema(factory.Factory):
+    FACTORY_FOR = ckanext_model.MetadataSchema
 
-    title = factory.Sequence(lambda n: 'Test Metadata Model {0:02d}'.format(n))
-    description = 'A test description for this test metadata model.'
-    model_json = '{"type": "object"}'
+    title = factory.Sequence(lambda n: 'Test Metadata Schema {0:02d}'.format(n))
+    description = 'A test description for this test metadata schema.'
+    schema_json = '{"type": "object"}'
     organization_id = ''
     infrastructure_id = ''
 
@@ -110,7 +110,7 @@ def _create(cls, target_class, *args, **kwargs):
         context = {'user': ckan_factories._get_action_user_name(kwargs)}
         metadata_standard_id = kwargs.pop('metadata_standard_id', None) or MetadataStandard()['id']
 
-        return helpers.call_action('metadata_model_create',
+        return helpers.call_action('metadata_schema_create',
                                    context=context,
                                    metadata_standard_id=metadata_standard_id,
                                    **kwargs)
diff --git a/ckanext/metadata/tests/test_infrastructure_actions.py b/ckanext/metadata/tests/test_infrastructure_actions.py
index 4e4d081..a649f9b 100644
--- a/ckanext/metadata/tests/test_infrastructure_actions.py
+++ b/ckanext/metadata/tests/test_infrastructure_actions.py
@@ -105,15 +105,15 @@ def test_delete_valid(self):
 
     def test_delete_with_dependencies(self):
         infrastructure = ckanext_factories.Infrastructure()
-        metadata_model = ckanext_factories.MetadataModel(infrastructure_id=infrastructure['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(infrastructure_id=infrastructure['id'])
         metadata_record = ckanext_factories.MetadataRecord(infrastructures=[{'id': infrastructure['id']}])
 
         result, obj = self.test_action('infrastructure_delete', should_error=True,
                                        id=infrastructure['id'])
         assert_error(result, 'message', 'Infrastructure has dependent metadata records')
-        assert ckanext_model.MetadataModel.get(metadata_model['id']).state == 'active'
+        assert ckanext_model.MetadataSchema.get(metadata_schema['id']).state == 'active'
 
         call_action('metadata_record_delete', id=metadata_record['id'])
         self.test_action('infrastructure_delete',
                          id=infrastructure['id'])
-        assert ckanext_model.MetadataModel.get(metadata_model['id']).state == 'deleted'
+        assert ckanext_model.MetadataSchema.get(metadata_schema['id']).state == 'deleted'
diff --git a/ckanext/metadata/tests/test_metadata_record_actions.py b/ckanext/metadata/tests/test_metadata_record_actions.py
index 4dedb3c..54adaae 100644
--- a/ckanext/metadata/tests/test_metadata_record_actions.py
+++ b/ckanext/metadata/tests/test_metadata_record_actions.py
@@ -14,7 +14,7 @@
     assert_error,
     assert_object_matches_dict,
     assert_package_has_attribute,
-    assert_metadata_record_has_validation_models,
+    assert_metadata_record_has_validation_schemas,
     factories as ckanext_factories,
     load_example,
 )
@@ -47,20 +47,20 @@ def _generate_metadata_record(self, **kwargs):
 
     def _validate_metadata_record(self, metadata_record):
         """
-        Create a (trivial) metadata model and validate the given record against it.
+        Create a (trivial) metadata schema and validate the given record against it.
         :param metadata_record: metadata record dict
-        :return: the metadata model (dict) used to validate the record
+        :return: the metadata schema (dict) used to validate the record
         """
-        metadata_model = ckanext_factories.MetadataModel(
+        metadata_schema = ckanext_factories.MetadataSchema(
             metadata_standard_id=metadata_record['metadata_standard_id'],
             infrastructure_id=metadata_record['infrastructures'][0]['id'] if metadata_record['infrastructures'] else ''
         )
         call_action('metadata_record_validate', id=metadata_record['id'], context={'user': self.normal_user['name']})
         assert_package_has_extra(metadata_record['id'], 'validated', True)
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
-        self.assert_validate_activity_logged(metadata_record['id'], metadata_model)
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
+        self.assert_validate_activity_logged(metadata_record['id'], metadata_schema)
 
-        return metadata_model
+        return metadata_schema
 
     def _make_input_dict(self):
         return {
@@ -286,7 +286,7 @@ def test_update_valid_partial(self):
 
     def test_update_json_invalidate(self):
         metadata_record = self._generate_metadata_record()
-        metadata_model = self._validate_metadata_record(metadata_record)
+        metadata_schema = self._validate_metadata_record(metadata_record)
 
         input_dict = self._make_input_dict_from_output_dict(metadata_record)
         input_dict['metadata_json'] = '{ "newtestkey": "newtestvalue" }'
@@ -295,12 +295,12 @@ def test_update_json_invalidate(self):
         self._assert_metadata_record_ok(obj, input_dict,
                                         name=input_dict['name'],
                                         validated=False)
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
         self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_record_update', obj)
 
     def test_update_standard_invalidate(self):
         metadata_record = self._generate_metadata_record()
-        metadata_model = self._validate_metadata_record(metadata_record)
+        metadata_schema = self._validate_metadata_record(metadata_record)
         input_dict = self._make_input_dict_from_output_dict(metadata_record)
 
         new_metadata_standard = ckanext_factories.MetadataStandard()
@@ -311,17 +311,17 @@ def test_update_standard_invalidate(self):
                                         name=input_dict['name'],
                                         metadata_standard_id=new_metadata_standard['id'],
                                         validated=False)
-        assert_metadata_record_has_validation_models(metadata_record['id'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'])
         self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_record_update', obj)
 
     def test_update_owner_org_invalidate(self):
         metadata_record = self._generate_metadata_record()
-        metadata_model = self._validate_metadata_record(metadata_record)
+        metadata_schema = self._validate_metadata_record(metadata_record)
         input_dict = self._make_input_dict_from_output_dict(metadata_record)
 
         new_organization = self._generate_organization()
         new_metadata_collection = self._generate_metadata_collection(organization_id=new_organization['id'])
-        new_metadata_model = ckanext_factories.MetadataModel(metadata_standard_id=metadata_record['metadata_standard_id'],
+        new_metadata_schema = ckanext_factories.MetadataSchema(metadata_standard_id=metadata_record['metadata_standard_id'],
                                                              organization_id=new_organization['id'])
         assert_package_has_extra(metadata_record['id'], 'validated', True)
 
@@ -335,18 +335,18 @@ def test_update_owner_org_invalidate(self):
                                         owner_org=new_organization['id'],
                                         metadata_collection_id=new_metadata_collection['id'],
                                         validated=False)
-        assert_metadata_record_has_validation_models(metadata_record['id'],
-                                                     metadata_model['name'], new_metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'],
+                                                     metadata_schema['name'], new_metadata_schema['name'])
         self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_record_update', obj)
 
     def test_update_infrastructures_invalidate(self):
         infrastructure = self._generate_infrastructure()
         metadata_record = self._generate_metadata_record(infrastructures=[{'id': infrastructure['id']}])
-        metadata_model = self._validate_metadata_record(metadata_record)
+        metadata_schema = self._validate_metadata_record(metadata_record)
         input_dict = self._make_input_dict_from_output_dict(metadata_record)
 
         new_infrastructure = self._generate_infrastructure()
-        new_metadata_model = ckanext_factories.MetadataModel(metadata_standard_id=metadata_record['metadata_standard_id'],
+        new_metadata_schema = ckanext_factories.MetadataSchema(metadata_standard_id=metadata_record['metadata_standard_id'],
                                                              infrastructure_id=new_infrastructure['id'])
         assert_package_has_extra(metadata_record['id'], 'validated', True)
 
@@ -355,12 +355,12 @@ def test_update_infrastructures_invalidate(self):
         self._assert_metadata_record_ok(obj, input_dict,
                                         name=input_dict['name'],
                                         validated=False)
-        assert_metadata_record_has_validation_models(metadata_record['id'], new_metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], new_metadata_schema['name'])
         self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_record_update', obj)
 
     def test_update_no_invalidate(self):
         metadata_record = self._generate_metadata_record()
-        metadata_model = self._validate_metadata_record(metadata_record)
+        metadata_schema = self._validate_metadata_record(metadata_record)
         input_dict = self._make_input_dict_from_output_dict(metadata_record)
 
         new_infrastructure = self._generate_infrastructure()
@@ -369,7 +369,7 @@ def test_update_no_invalidate(self):
         self._assert_metadata_record_ok(obj, input_dict,
                                         name=input_dict['name'],
                                         validated=True)
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
 
         new_organization = self._generate_organization()
         new_metadata_collection = self._generate_metadata_collection(organization_id=new_organization['id'])
@@ -383,7 +383,7 @@ def test_update_no_invalidate(self):
                                         owner_org=new_organization['id'],
                                         metadata_collection_id=new_metadata_collection['id'],
                                         validated=True)
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
 
     def test_update_invalid_duplicate_name(self):
         metadata_record1 = self._generate_metadata_record()
@@ -481,7 +481,7 @@ def test_delete_valid(self):
 
     def test_invalidate(self):
         metadata_record = self._generate_metadata_record()
-        metadata_model = self._validate_metadata_record(metadata_record)
+        metadata_schema = self._validate_metadata_record(metadata_record)
         input_dict = self._make_input_dict_from_output_dict(metadata_record)
 
         result, obj = self.test_action('metadata_record_invalidate',
@@ -489,22 +489,22 @@ def test_invalidate(self):
         self._assert_metadata_record_ok(obj, input_dict,
                                         name=input_dict['name'],
                                         validated=False)
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
         self.assert_invalidate_activity_logged(metadata_record['id'], None, None)
 
     def test_validate_datacite(self):
         metadata_record = self._generate_metadata_record(
             metadata_json=load_example('saeon_datacite_record.json'))
-        metadata_model = ckanext_factories.MetadataModel(
+        metadata_schema = ckanext_factories.MetadataSchema(
             metadata_standard_id=metadata_record['metadata_standard_id'],
-            model_json=load_example('saeon_datacite_model.json'))
+            schema_json=load_example('saeon_datacite_schema.json'))
         ckan_factories.Vocabulary(name='language-tags', tags=[{'name': 'en-us'}])
 
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
         self.test_action('metadata_record_validate', id=metadata_record['id'])
         assert_package_has_extra(metadata_record['id'], 'validated', True)
         assert_package_has_extra(metadata_record['id'], 'errors', '{}')
-        self.assert_validate_activity_logged(metadata_record['id'], metadata_model)
+        self.assert_validate_activity_logged(metadata_record['id'], metadata_schema)
 
     def test_workflow_annotations_valid(self):
         metadata_record = self._generate_metadata_record()
@@ -740,9 +740,9 @@ def test_workflow_transition_published(self):
         metadata_record = self._generate_metadata_record(
             metadata_json=json.dumps(metadata_json))
 
-        ckanext_factories.MetadataModel(
+        ckanext_factories.MetadataSchema(
             metadata_standard_id=metadata_record['metadata_standard_id'],
-            model_json=load_example('saeon_datacite_model.json'))
+            schema_json=load_example('saeon_datacite_schema.json'))
         call_action('metadata_record_validate', id=metadata_record['id'], context={'user': self.normal_user['name']})
 
         workflow_state_published = ckanext_factories.WorkflowState(
diff --git a/ckanext/metadata/tests/test_metadata_model_actions.py b/ckanext/metadata/tests/test_metadata_schema_actions.py
similarity index 52%
rename from ckanext/metadata/tests/test_metadata_model_actions.py
rename to ckanext/metadata/tests/test_metadata_schema_actions.py
index 018a91d..93b53c1 100644
--- a/ckanext/metadata/tests/test_metadata_model_actions.py
+++ b/ckanext/metadata/tests/test_metadata_schema_actions.py
@@ -13,55 +13,55 @@
     assert_object_matches_dict,
     assert_error,
     assert_package_has_extra,
-    assert_metadata_record_has_validation_models,
-    assert_metadata_model_has_dependent_records,
+    assert_metadata_record_has_validation_schemas,
+    assert_metadata_schema_has_dependent_records,
     factories as ckanext_factories,
     load_example,
 )
 
 
-class TestMetadataModelActions(ActionTestBase):
+class TestMetadataSchemaActions(ActionTestBase):
 
     def _generate_and_validate_metadata_record(self, metadata_standard_id=None,
                                                add_infrastructure_to_record=False,
-                                               add_organization_to_model=False,
-                                               add_infrastructure_to_model=False):
+                                               add_organization_to_schema=False,
+                                               add_infrastructure_to_schema=False):
         """
-        Generate a metadata record and a metadata model, and validate the record using the model.
+        Generate a metadata record and a metadata schema, and validate the record using the schema.
         :param metadata_standard_id: specify the metadata standard to use
         :param add_infrastructure_to_record: assign an infrastructure to the record
-        :param add_organization_to_model: associate the record's organization with the model
-        :param add_infrastructure_to_model: associate the record's infrastructure with the model
-        :return: tuple of new record and model dictionaries
+        :param add_organization_to_schema: associate the record's organization with the schema
+        :param add_infrastructure_to_schema: associate the record's infrastructure with the schema
+        :return: tuple of new record and schema dictionaries
         """
         metadata_record = ckanext_factories.MetadataRecord(
             metadata_standard_id=metadata_standard_id,
             infrastructures=[{'id': ckanext_factories.Infrastructure()['id']}] if add_infrastructure_to_record else [])
 
-        metadata_model = ckanext_factories.MetadataModel(
+        metadata_schema = ckanext_factories.MetadataSchema(
             metadata_standard_id=metadata_record['metadata_standard_id'],
-            organization_id=metadata_record['owner_org'] if add_organization_to_model else '',
-            infrastructure_id=metadata_record['infrastructures'][0]['id'] if add_infrastructure_to_model else '')
+            organization_id=metadata_record['owner_org'] if add_organization_to_schema else '',
+            infrastructure_id=metadata_record['infrastructures'][0]['id'] if add_infrastructure_to_schema else '')
 
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
         self._validate_metadata_record(metadata_record)
-        self.assert_validate_activity_logged(metadata_record['id'], metadata_model)
-        return metadata_record, metadata_model
+        self.assert_validate_activity_logged(metadata_record['id'], metadata_schema)
+        return metadata_record, metadata_schema
 
-    def _generate_and_validate_metadata_record_using_model(self, metadata_model):
+    def _generate_and_validate_metadata_record_using_schema(self, metadata_schema):
         """
-        Generate a metadata record with the same standard and organization/infrastructure of the given model,
-        and validate it using this model.
+        Generate a metadata record with the same standard and organization/infrastructure of the given schema,
+        and validate it using this schema.
         :return: metadata record dict
         """
         metadata_record = ckanext_factories.MetadataRecord(
-            metadata_standard_id=metadata_model['metadata_standard_id'],
-            owner_org=metadata_model['organization_id'],
-            infrastructures=[{'id': metadata_model['infrastructure_id']}] if metadata_model['infrastructure_id'] else [])
+            metadata_standard_id=metadata_schema['metadata_standard_id'],
+            owner_org=metadata_schema['organization_id'],
+            infrastructures=[{'id': metadata_schema['infrastructure_id']}] if metadata_schema['infrastructure_id'] else [])
 
-        assert_metadata_record_has_validation_models(metadata_record['id'], metadata_model['name'])
+        assert_metadata_record_has_validation_schemas(metadata_record['id'], metadata_schema['name'])
         self._validate_metadata_record(metadata_record)
-        self.assert_validate_activity_logged(metadata_record['id'], metadata_model)
+        self.assert_validate_activity_logged(metadata_record['id'], metadata_schema)
         return metadata_record
 
     def _validate_metadata_record(self, metadata_record):
@@ -74,14 +74,14 @@ def _validate_metadata_record(self, metadata_record):
     def test_create_valid(self):
         metadata_standard = ckanext_factories.MetadataStandard()
         input_dict = {
-            'title': 'Test Metadata Model',
-            'description': 'This is a test metadata model',
+            'title': 'Test Metadata Schema',
+            'description': 'This is a test metadata schema',
             'metadata_standard_id': metadata_standard['id'],
             'organization_id': '',
             'infrastructure_id': '',
-            'model_json': '{ "testkey": "testvalue" }',
+            'schema_json': '{ "testkey": "testvalue" }',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert_object_matches_dict(obj, input_dict)
         assert obj.name == generate_name(metadata_standard['name'], '', '')
 
@@ -91,21 +91,21 @@ def test_create_valid_datacite(self):
             'metadata_standard_id': metadata_standard['id'],
             'organization_id': '',
             'infrastructure_id': '',
-            'model_json': load_example('saeon_datacite_model.json'),
+            'schema_json': load_example('saeon_datacite_schema.json'),
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_create_valid_setname(self):
         metadata_standard = ckanext_factories.MetadataStandard()
         input_dict = {
-            'name': 'test-metadata-model',
+            'name': 'test-metadata-schema',
             'metadata_standard_id': metadata_standard['id'],
             'organization_id': '',
             'infrastructure_id': '',
-            'model_json': '{ "testkey": "testvalue" }',
+            'schema_json': '{ "testkey": "testvalue" }',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_create_valid_with_organization_byname(self):
@@ -115,9 +115,9 @@ def test_create_valid_with_organization_byname(self):
             'metadata_standard_id': metadata_standard['name'],
             'organization_id': organization['name'],
             'infrastructure_id': '',
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert obj.metadata_standard_id == metadata_standard['id']
         assert obj.organization_id == organization['id']
         assert obj.infrastructure_id is None
@@ -130,9 +130,9 @@ def test_create_valid_with_infrastructure_byname(self):
             'metadata_standard_id': metadata_standard['name'],
             'organization_id': '',
             'infrastructure_id': infrastructure['name'],
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert obj.metadata_standard_id == metadata_standard['id']
         assert obj.organization_id is None
         assert obj.infrastructure_id == infrastructure['id']
@@ -145,237 +145,237 @@ def test_create_valid_sysadmin_setid(self):
             'metadata_standard_id': metadata_standard['id'],
             'organization_id': '',
             'infrastructure_id': '',
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_create', sysadmin=True, check_auth=True, **input_dict)
+        result, obj = self.test_action('metadata_schema_create', sysadmin=True, check_auth=True, **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_create_valid_same_standard_different_organization(self):
         organization1 = ckan_factories.Organization()
         organization2 = ckan_factories.Organization()
-        metadata_model = ckanext_factories.MetadataModel(organization_id=organization1['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(organization_id=organization1['id'])
         input_dict = {
-            'metadata_standard_id': metadata_model['metadata_standard_id'],
+            'metadata_standard_id': metadata_schema['metadata_standard_id'],
             'organization_id': organization2['id'],
             'infrastructure_id': '',
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_create_valid_same_standard_different_infrastructure(self):
         infrastructure1 = ckanext_factories.Infrastructure()
         infrastructure2 = ckanext_factories.Infrastructure()
-        metadata_model = ckanext_factories.MetadataModel(infrastructure_id=infrastructure1['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(infrastructure_id=infrastructure1['id'])
         input_dict = {
-            'metadata_standard_id': metadata_model['metadata_standard_id'],
+            'metadata_standard_id': metadata_schema['metadata_standard_id'],
             'organization_id': '',
             'infrastructure_id': infrastructure2['id'],
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_create_valid_same_organization_different_standard(self):
         organization = ckan_factories.Organization()
-        metadata_model = ckanext_factories.MetadataModel(organization_id=organization['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(organization_id=organization['id'])
         metadata_standard = ckanext_factories.MetadataStandard()
         input_dict = {
             'metadata_standard_id': metadata_standard['id'],
-            'organization_id': metadata_model['organization_id'],
+            'organization_id': metadata_schema['organization_id'],
             'infrastructure_id': '',
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_create_valid_same_infrastructure_different_standard(self):
         infrastructure = ckanext_factories.Infrastructure()
-        metadata_model = ckanext_factories.MetadataModel(infrastructure_id=infrastructure['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(infrastructure_id=infrastructure['id'])
         metadata_standard = ckanext_factories.MetadataStandard()
         input_dict = {
             'metadata_standard_id': metadata_standard['id'],
             'organization_id': '',
-            'infrastructure_id': metadata_model['infrastructure_id'],
-            'model_json': '{}',
+            'infrastructure_id': metadata_schema['infrastructure_id'],
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_create', **input_dict)
+        result, obj = self.test_action('metadata_schema_create', **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_create_invalidate_records_matching_standard(self):
         """
-        Create a model that will be used for validating an existing validated metadata record by virtue
+        Create a schema that will be used for validating an existing validated metadata record by virtue
         of matching on the record's metadata standard. This should invalidate the record.
         """
-        # add org to model to avoid unique key violation below
-        metadata_record, _ = self._generate_and_validate_metadata_record(add_organization_to_model=True)
-        result, obj = self.test_action('metadata_model_create',
+        # add org to schema to avoid unique key violation below
+        metadata_record, _ = self._generate_and_validate_metadata_record(add_organization_to_schema=True)
+        result, obj = self.test_action('metadata_schema_create',
                                        metadata_standard_id=metadata_record['metadata_standard_id'],
                                        organization_id='',
                                        infrastructure_id='',
-                                       model_json='{}')
+                                       schema_json='{}')
         assert_package_has_extra(metadata_record['id'], 'validated', False)
-        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_model_create', obj)
+        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_schema_create', obj)
 
     def test_create_invalidate_records_matching_standard_organization(self):
         """
-        Create a model that will be used for validating an existing validated metadata record by virtue
+        Create a schema that will be used for validating an existing validated metadata record by virtue
         of matching on standard and organization. This should invalidate the record.
         """
         metadata_record, _ = self._generate_and_validate_metadata_record()
-        result, obj = self.test_action('metadata_model_create',
+        result, obj = self.test_action('metadata_schema_create',
                                        metadata_standard_id=metadata_record['metadata_standard_id'],
                                        organization_id=metadata_record['owner_org'],
                                        infrastructure_id='',
-                                       model_json='{}')
+                                       schema_json='{}')
         assert_package_has_extra(metadata_record['id'], 'validated', False)
-        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_model_create', obj)
+        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_schema_create', obj)
 
     def test_create_invalidate_records_matching_standard_infrastructure(self):
         """
-        Create a model that will be used for validating an existing validated metadata record by virtue
+        Create a schema that will be used for validating an existing validated metadata record by virtue
         of matching on standard and infrastructure. This should invalidate the record.
         """
         metadata_record, _ = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True)
-        result, obj = self.test_action('metadata_model_create',
+        result, obj = self.test_action('metadata_schema_create',
                                        metadata_standard_id=metadata_record['metadata_standard_id'],
                                        organization_id='',
                                        infrastructure_id=metadata_record['infrastructures'][0]['id'],
-                                       model_json='{}')
+                                       schema_json='{}')
         assert_package_has_extra(metadata_record['id'], 'validated', False)
-        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_model_create', obj)
+        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_schema_create', obj)
 
     def test_create_no_invalidate_records_different_standard(self):
         """
-        Create a model with a different standard to that of an existing validated metadata record.
+        Create a schema with a different standard to that of an existing validated metadata record.
         This should not invalidate the record.
         """
         metadata_record, _ = self._generate_and_validate_metadata_record()
-        call_action('metadata_model_create',
+        call_action('metadata_schema_create',
                     metadata_standard_id=ckanext_factories.MetadataStandard()['id'],
                     organization_id='',
                     infrastructure_id='',
-                    model_json='{}')
+                    schema_json='{}')
         assert_package_has_extra(metadata_record['id'], 'validated', True)
 
     def test_create_no_invalidate_records_different_organization(self):
         """
-        Create a model with the same standard but a different organization to that of an existing
+        Create a schema with the same standard but a different organization to that of an existing
         validated metadata record. This should not invalidate the record.
         """
         metadata_record, _ = self._generate_and_validate_metadata_record()
-        call_action('metadata_model_create',
+        call_action('metadata_schema_create',
                     metadata_standard_id=metadata_record['metadata_standard_id'],
                     organization_id=ckan_factories.Organization()['id'],
                     infrastructure_id='',
-                    model_json='{}')
+                    schema_json='{}')
         assert_package_has_extra(metadata_record['id'], 'validated', True)
 
     def test_create_no_invalidate_records_different_infrastructure_1(self):
         """
-        Create a model with the same standard but a different infrastructure to that of an existing
+        Create a schema with the same standard but a different infrastructure to that of an existing
         validated metadata record. This should not invalidate the record.
         """
         metadata_record, _ = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True)
-        call_action('metadata_model_create',
+        call_action('metadata_schema_create',
                     metadata_standard_id=metadata_record['metadata_standard_id'],
                     organization_id='',
                     infrastructure_id=ckanext_factories.Infrastructure()['id'],
-                    model_json='{}')
+                    schema_json='{}')
         assert_package_has_extra(metadata_record['id'], 'validated', True)
 
     def test_create_no_invalidate_records_different_infrastructure_2(self):
         """
-        Create a model with the same standard but a different infrastructure to that of an existing
+        Create a schema with the same standard but a different infrastructure to that of an existing
         validated metadata record. This should not invalidate the record.
         """
         metadata_record, _ = self._generate_and_validate_metadata_record()
-        call_action('metadata_model_create',
+        call_action('metadata_schema_create',
                     metadata_standard_id=metadata_record['metadata_standard_id'],
                     organization_id='',
                     infrastructure_id=ckanext_factories.Infrastructure()['id'],
-                    model_json='{}')
+                    schema_json='{}')
         assert_package_has_extra(metadata_record['id'], 'validated', True)
 
     def test_create_invalid_duplicate_name(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       name=metadata_model['name'])
-        assert_error(result, 'name', 'Duplicate name: Metadata Model')
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       name=metadata_schema['name'])
+        assert_error(result, 'name', 'Duplicate name: Metadata Schema')
 
     def test_create_invalid_duplicate_standard(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       metadata_standard_id=metadata_model['metadata_standard_id'])
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'])
         assert_error(result, '__after', 'Unique constraint violation')
 
     def test_create_invalid_duplicate_standard_organization(self):
         organization = ckan_factories.Organization()
-        metadata_model = ckanext_factories.MetadataModel(organization_id=organization['id'])
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       metadata_standard_id=metadata_model['metadata_standard_id'],
-                                       organization_id=metadata_model['organization_id'])
+        metadata_schema = ckanext_factories.MetadataSchema(organization_id=organization['id'])
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'],
+                                       organization_id=metadata_schema['organization_id'])
         assert_error(result, '__after', 'Unique constraint violation')
 
     def test_create_invalid_duplicate_standard_infrastructure(self):
         infrastructure = ckanext_factories.Infrastructure()
-        metadata_model = ckanext_factories.MetadataModel(infrastructure_id=infrastructure['id'])
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       metadata_standard_id=metadata_model['metadata_standard_id'],
-                                       infrastructure_id=metadata_model['infrastructure_id'])
+        metadata_schema = ckanext_factories.MetadataSchema(infrastructure_id=infrastructure['id'])
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'],
+                                       infrastructure_id=metadata_schema['infrastructure_id'])
         assert_error(result, '__after', 'Unique constraint violation')
 
     def test_create_invalid_with_organization_and_infrastructure(self):
         organization = ckan_factories.Organization()
         infrastructure = ckanext_factories.Infrastructure()
-        result, obj = self.test_action('metadata_model_create', should_error=True,
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
                                        organization_id=organization['id'],
                                        infrastructure_id=infrastructure['id'])
         assert_error(result, '__after',
-                     'A metadata model may be associated with either an organization or an infrastructure but not both.')
+                     'A metadata schema may be associated with either an organization or an infrastructure but not both.')
 
     def test_create_invalid_nonsysadmin_setid(self):
-        result, obj = self.test_action('metadata_model_create', should_error=True, check_auth=True,
+        result, obj = self.test_action('metadata_schema_create', should_error=True, check_auth=True,
                                        id=make_uuid())
         assert_error(result, 'id', 'The input field id was not expected.')
 
     def test_create_invalid_sysadmin_duplicate_id(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_create', should_error=True, sysadmin=True, check_auth=True,
-                                       id=metadata_model['id'])
-        assert_error(result, 'id', 'Already exists: Metadata Model')
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_create', should_error=True, sysadmin=True, check_auth=True,
+                                       id=metadata_schema['id'])
+        assert_error(result, 'id', 'Already exists: Metadata Schema')
 
     def test_create_invalid_not_json(self):
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       model_json='not json')
-        assert_error(result, 'model_json', 'JSON decode error')
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       schema_json='not json')
+        assert_error(result, 'schema_json', 'JSON decode error')
 
     def test_create_invalid_not_json_dict(self):
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       model_json='[1,2,3]')
-        assert_error(result, 'model_json', 'Expecting a JSON dictionary')
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       schema_json='[1,2,3]')
+        assert_error(result, 'schema_json', 'Expecting a JSON dictionary')
 
     def test_create_invalid_not_json_schema(self):
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       model_json='{"type": "foo"}')
-        assert_error(result, 'model_json', 'Invalid JSON schema')
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       schema_json='{"type": "foo"}')
+        assert_error(result, 'schema_json', 'Invalid JSON schema')
 
     def test_create_invalid_missing_params(self):
-        result, obj = self.test_action('metadata_model_create', should_error=True)
+        result, obj = self.test_action('metadata_schema_create', should_error=True)
         assert_error(result, 'metadata_standard_id', 'Missing parameter')
         assert_error(result, 'organization_id', 'Missing parameter')
         assert_error(result, 'infrastructure_id', 'Missing parameter')
-        assert_error(result, 'model_json', 'Missing parameter')
+        assert_error(result, 'schema_json', 'Missing parameter')
 
     def test_create_invalid_missing_values(self):
-        result, obj = self.test_action('metadata_model_create', should_error=True,
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
                                        metadata_standard_id='',
-                                       model_json='')
+                                       schema_json='')
         assert_error(result, 'metadata_standard_id', 'Missing value')
-        assert_error(result, 'model_json', 'Missing value')
+        assert_error(result, 'schema_json', 'Missing value')
 
     def test_create_invalid_bad_references(self):
-        result, obj = self.test_action('metadata_model_create', should_error=True,
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
                                        metadata_standard_id='a',
                                        organization_id='b',
                                        infrastructure_id='c')
@@ -391,7 +391,7 @@ def test_create_invalid_deleted_references(self):
         call_action('organization_delete', id=organization['id'])
         call_action('infrastructure_delete', id=infrastructure['id'])
 
-        result, obj = self.test_action('metadata_model_create', should_error=True,
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
                                        metadata_standard_id=metadata_standard['id'],
                                        organization_id=organization['id'],
                                        infrastructure_id=infrastructure['id'])
@@ -400,329 +400,329 @@ def test_create_invalid_deleted_references(self):
         assert_error(result, 'infrastructure_id', 'Not found: Infrastructure')
 
     def test_update_valid(self):
-        metadata_model = ckanext_factories.MetadataModel()
+        metadata_schema = ckanext_factories.MetadataSchema()
         metadata_standard = ckanext_factories.MetadataStandard()
         input_dict = {
-            'id': metadata_model['id'],
-            'title': 'Updated Test Metadata Model',
-            'description': 'Updated test metadata model description',
+            'id': metadata_schema['id'],
+            'title': 'Updated Test Metadata Schema',
+            'description': 'Updated test metadata schema description',
             'metadata_standard_id': metadata_standard['id'],
             'organization_id': '',
             'infrastructure_id': '',
-            'model_json': '{ "testkey": "newtestvalue" }',
+            'schema_json': '{ "testkey": "newtestvalue" }',
         }
-        result, obj = self.test_action('metadata_model_update', **input_dict)
+        result, obj = self.test_action('metadata_schema_update', **input_dict)
         assert_object_matches_dict(obj, input_dict)
         assert obj.name == generate_name(metadata_standard['name'], '', '')
 
     def test_update_valid_partial(self):
-        metadata_model = ckanext_factories.MetadataModel()
+        metadata_schema = ckanext_factories.MetadataSchema()
         input_dict = {
-            'id': metadata_model['id'],
-            'name': 'updated-test-metadata-model',
-            'metadata_standard_id': metadata_model['metadata_standard_id'],
+            'id': metadata_schema['id'],
+            'name': 'updated-test-metadata-schema',
+            'metadata_standard_id': metadata_schema['metadata_standard_id'],
             'organization_id': '',
             'infrastructure_id': '',
-            'model_json': '{ "testkey": "newtestvalue" }',
+            'schema_json': '{ "testkey": "newtestvalue" }',
         }
-        result, obj = self.test_action('metadata_model_update', **input_dict)
+        result, obj = self.test_action('metadata_schema_update', **input_dict)
         assert_object_matches_dict(obj, input_dict)
-        assert obj.title == metadata_model['title']
-        assert obj.description == metadata_model['description']
+        assert obj.title == metadata_schema['title']
+        assert obj.description == metadata_schema['description']
 
     def test_update_valid_datacite(self):
-        metadata_model = ckanext_factories.MetadataModel()
+        metadata_schema = ckanext_factories.MetadataSchema()
         input_dict = {
-            'id': metadata_model['id'],
-            'metadata_standard_id': metadata_model['metadata_standard_id'],
+            'id': metadata_schema['id'],
+            'metadata_standard_id': metadata_schema['metadata_standard_id'],
             'organization_id': '',
             'infrastructure_id': '',
-            'model_json': load_example('saeon_datacite_model.json'),
+            'schema_json': load_example('saeon_datacite_schema.json'),
         }
-        result, obj = self.test_action('metadata_model_update', **input_dict)
+        result, obj = self.test_action('metadata_schema_update', **input_dict)
         assert_object_matches_dict(obj, input_dict)
 
     def test_update_valid_set_organization(self):
-        metadata_model = ckanext_factories.MetadataModel()
+        metadata_schema = ckanext_factories.MetadataSchema()
         organization = ckan_factories.Organization()
         input_dict = {
-            'id': metadata_model['id'],
-            'metadata_standard_id': metadata_model['metadata_standard_id'],
+            'id': metadata_schema['id'],
+            'metadata_standard_id': metadata_schema['metadata_standard_id'],
             'organization_id': organization['id'],
             'infrastructure_id': '',
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_update', **input_dict)
+        result, obj = self.test_action('metadata_schema_update', **input_dict)
         assert_object_matches_dict(obj, input_dict)
-        metadata_standard = ckanext_model.MetadataStandard.get(metadata_model['metadata_standard_id'])
+        metadata_standard = ckanext_model.MetadataStandard.get(metadata_schema['metadata_standard_id'])
         assert obj.name == generate_name(metadata_standard.name, organization['name'], '')
 
     def test_update_valid_set_infrastructure(self):
-        metadata_model = ckanext_factories.MetadataModel()
+        metadata_schema = ckanext_factories.MetadataSchema()
         infrastructure = ckanext_factories.Infrastructure()
         input_dict = {
-            'id': metadata_model['id'],
-            'metadata_standard_id': metadata_model['metadata_standard_id'],
+            'id': metadata_schema['id'],
+            'metadata_standard_id': metadata_schema['metadata_standard_id'],
             'organization_id': '',
             'infrastructure_id': infrastructure['id'],
-            'model_json': '{}',
+            'schema_json': '{}',
         }
-        result, obj = self.test_action('metadata_model_update', **input_dict)
+        result, obj = self.test_action('metadata_schema_update', **input_dict)
         assert_object_matches_dict(obj, input_dict)
-        metadata_standard = ckanext_model.MetadataStandard.get(metadata_model['metadata_standard_id'])
+        metadata_standard = ckanext_model.MetadataStandard.get(metadata_schema['metadata_standard_id'])
         assert obj.name == generate_name(metadata_standard.name, '', infrastructure['name'])
 
     def test_update_json_invalidate_records_1(self):
         """
-        Update the JSON of a model that was used to validate existing metadata records that are associated with
+        Update the JSON of a schema that was used to validate existing metadata records that are associated with
         different organizations and infrastructures. This should invalidate all those records.
         """
-        metadata_record_1, metadata_model = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True)
-        metadata_record_2 = self._generate_and_validate_metadata_record_using_model(metadata_model)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
+        metadata_record_1, metadata_schema = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True)
+        metadata_record_2 = self._generate_and_validate_metadata_record_using_schema(metadata_schema)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
 
-        result, obj = self.test_action('metadata_model_update',
-                                       id=metadata_model['id'],
-                                       metadata_standard_id=metadata_model['metadata_standard_id'],
+        result, obj = self.test_action('metadata_schema_update',
+                                       id=metadata_schema['id'],
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'],
                                        organization_id='',
                                        infrastructure_id='',
-                                       model_json='{ "newtestkey": "newtestvalue" }')
+                                       schema_json='{ "newtestkey": "newtestvalue" }')
 
         assert_package_has_extra(metadata_record_1['id'], 'validated', False)
         assert_package_has_extra(metadata_record_2['id'], 'validated', False)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
-        self.assert_invalidate_activity_logged(metadata_record_1['id'], 'metadata_model_update', obj)
-        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_model_update', obj)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
+        self.assert_invalidate_activity_logged(metadata_record_1['id'], 'metadata_schema_update', obj)
+        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_schema_update', obj)
 
     def test_update_json_invalidate_records_2(self):
         """
-        Update the JSON of a model that was used to validate existing metadata records that are associated with
+        Update the JSON of a schema that was used to validate existing metadata records that are associated with
         the same infrastructure and different organizations. This should invalidate all those records.
         """
-        metadata_record_1, metadata_model = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True, add_infrastructure_to_model=True)
-        metadata_record_2 = self._generate_and_validate_metadata_record_using_model(metadata_model)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
+        metadata_record_1, metadata_schema = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True, add_infrastructure_to_schema=True)
+        metadata_record_2 = self._generate_and_validate_metadata_record_using_schema(metadata_schema)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
 
-        result, obj = self.test_action('metadata_model_update',
-                                       id=metadata_model['id'],
-                                       metadata_standard_id=metadata_model['metadata_standard_id'],
+        result, obj = self.test_action('metadata_schema_update',
+                                       id=metadata_schema['id'],
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'],
                                        organization_id='',
-                                       infrastructure_id=metadata_model['infrastructure_id'],
-                                       model_json='{ "newtestkey": "newtestvalue" }')
+                                       infrastructure_id=metadata_schema['infrastructure_id'],
+                                       schema_json='{ "newtestkey": "newtestvalue" }')
 
         assert_package_has_extra(metadata_record_1['id'], 'validated', False)
         assert_package_has_extra(metadata_record_2['id'], 'validated', False)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
-        self.assert_invalidate_activity_logged(metadata_record_1['id'], 'metadata_model_update', obj)
-        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_model_update', obj)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
+        self.assert_invalidate_activity_logged(metadata_record_1['id'], 'metadata_schema_update', obj)
+        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_schema_update', obj)
 
     def test_update_json_invalidate_records_3(self):
         """
-        Update the JSON of a model that was used to validate existing metadata records that are associated with
+        Update the JSON of a schema that was used to validate existing metadata records that are associated with
         the same organization and different infrastructures. This should invalidate all those records.
         """
-        metadata_record_1, metadata_model = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True, add_organization_to_model=True)
-        metadata_record_2 = self._generate_and_validate_metadata_record_using_model(metadata_model)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
+        metadata_record_1, metadata_schema = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True, add_organization_to_schema=True)
+        metadata_record_2 = self._generate_and_validate_metadata_record_using_schema(metadata_schema)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
 
-        result, obj = self.test_action('metadata_model_update',
-                                       id=metadata_model['id'],
-                                       metadata_standard_id=metadata_model['metadata_standard_id'],
-                                       organization_id=metadata_model['organization_id'],
+        result, obj = self.test_action('metadata_schema_update',
+                                       id=metadata_schema['id'],
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'],
+                                       organization_id=metadata_schema['organization_id'],
                                        infrastructure_id='',
-                                       model_json='{ "newtestkey": "newtestvalue" }')
+                                       schema_json='{ "newtestkey": "newtestvalue" }')
 
         assert_package_has_extra(metadata_record_1['id'], 'validated', False)
         assert_package_has_extra(metadata_record_2['id'], 'validated', False)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
-        self.assert_invalidate_activity_logged(metadata_record_1['id'], 'metadata_model_update', obj)
-        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_model_update', obj)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
+        self.assert_invalidate_activity_logged(metadata_record_1['id'], 'metadata_schema_update', obj)
+        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_schema_update', obj)
 
     def test_update_infrastructure_invalidate_records_1(self):
         """
-        Assign an infrastructure to a model that was used to validate existing metadata records. This should invalidate
-        those records that are no longer dependent on the model due to not being associated with that infrastructure.
+        Assign an infrastructure to a schema that was used to validate existing metadata records. This should invalidate
+        those records that are no longer dependent on the schema due to not being associated with that infrastructure.
         """
-        metadata_record_1, metadata_model = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True)
-        metadata_record_2 = self._generate_and_validate_metadata_record_using_model(metadata_model)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
+        metadata_record_1, metadata_schema = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True)
+        metadata_record_2 = self._generate_and_validate_metadata_record_using_schema(metadata_schema)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
 
-        result, obj = self.test_action('metadata_model_update',
-                                       id=metadata_model['id'],
-                                       metadata_standard_id=metadata_model['metadata_standard_id'],
+        result, obj = self.test_action('metadata_schema_update',
+                                       id=metadata_schema['id'],
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'],
                                        organization_id='',
                                        infrastructure_id=metadata_record_1['infrastructures'][0]['id'],
-                                       model_json=json.dumps(metadata_model['model_json']))
+                                       schema_json=json.dumps(metadata_schema['schema_json']))
 
         assert_package_has_extra(metadata_record_1['id'], 'validated', True)
         assert_package_has_extra(metadata_record_2['id'], 'validated', False)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'])
-        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_model_update', obj)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'])
+        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_schema_update', obj)
 
     def test_update_infrastructure_invalidate_records_2(self):
         """
-        Unassign an infrastructure from a model. This should invalidate existing validated metadata records that are
-        newly dependent on the model.
+        Unassign an infrastructure from a schema. This should invalidate existing validated metadata records that are
+        newly dependent on the schema.
         """
-        metadata_record_1, metadata_model_1 = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True, add_infrastructure_to_model=True)
-        metadata_record_2, metadata_model_2 = self._generate_and_validate_metadata_record(metadata_standard_id=metadata_record_1['metadata_standard_id'], add_organization_to_model=True)
-        assert_metadata_model_has_dependent_records(metadata_model_1['id'], metadata_record_1['id'])
+        metadata_record_1, metadata_schema_1 = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True, add_infrastructure_to_schema=True)
+        metadata_record_2, metadata_schema_2 = self._generate_and_validate_metadata_record(metadata_standard_id=metadata_record_1['metadata_standard_id'], add_organization_to_schema=True)
+        assert_metadata_schema_has_dependent_records(metadata_schema_1['id'], metadata_record_1['id'])
 
-        result, obj = self.test_action('metadata_model_update',
-                                       id=metadata_model_1['id'],
-                                       metadata_standard_id=metadata_model_1['metadata_standard_id'],
+        result, obj = self.test_action('metadata_schema_update',
+                                       id=metadata_schema_1['id'],
+                                       metadata_standard_id=metadata_schema_1['metadata_standard_id'],
                                        organization_id='',
                                        infrastructure_id='',
-                                       model_json=json.dumps(metadata_model_1['model_json']))
+                                       schema_json=json.dumps(metadata_schema_1['schema_json']))
 
         assert_package_has_extra(metadata_record_1['id'], 'validated', True)
         assert_package_has_extra(metadata_record_2['id'], 'validated', False)
-        assert_metadata_model_has_dependent_records(metadata_model_1['id'], metadata_record_1['id'], metadata_record_2['id'])
-        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_model_update', obj)
+        assert_metadata_schema_has_dependent_records(metadata_schema_1['id'], metadata_record_1['id'], metadata_record_2['id'])
+        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_schema_update', obj)
 
     def test_update_organization_invalidate_records_1(self):
         """
-        Assign an organization to a model that was used to validate existing metadata records. This should invalidate
-        those records that are no longer dependent on the model due to not being associated with that organization.
+        Assign an organization to a schema that was used to validate existing metadata records. This should invalidate
+        those records that are no longer dependent on the schema due to not being associated with that organization.
         """
-        metadata_record_1, metadata_model = self._generate_and_validate_metadata_record()
-        metadata_record_2 = self._generate_and_validate_metadata_record_using_model(metadata_model)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'], metadata_record_2['id'])
+        metadata_record_1, metadata_schema = self._generate_and_validate_metadata_record()
+        metadata_record_2 = self._generate_and_validate_metadata_record_using_schema(metadata_schema)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'], metadata_record_2['id'])
 
-        result, obj = self.test_action('metadata_model_update',
-                                       id=metadata_model['id'],
-                                       metadata_standard_id=metadata_model['metadata_standard_id'],
+        result, obj = self.test_action('metadata_schema_update',
+                                       id=metadata_schema['id'],
+                                       metadata_standard_id=metadata_schema['metadata_standard_id'],
                                        organization_id=metadata_record_1['owner_org'],
                                        infrastructure_id='',
-                                       model_json=json.dumps(metadata_model['model_json']))
+                                       schema_json=json.dumps(metadata_schema['schema_json']))
 
         assert_package_has_extra(metadata_record_1['id'], 'validated', True)
         assert_package_has_extra(metadata_record_2['id'], 'validated', False)
-        assert_metadata_model_has_dependent_records(metadata_model['id'], metadata_record_1['id'])
-        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_model_update', obj)
+        assert_metadata_schema_has_dependent_records(metadata_schema['id'], metadata_record_1['id'])
+        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_schema_update', obj)
 
     def test_update_organization_invalidate_records_2(self):
         """
-        Unassign an organization from a model. This should invalidate existing validated metadata records that are
-        newly dependent on the model.
+        Unassign an organization from a schema. This should invalidate existing validated metadata records that are
+        newly dependent on the schema.
         """
-        metadata_record_1, metadata_model_1 = self._generate_and_validate_metadata_record(add_organization_to_model=True)
-        metadata_record_2, metadata_model_2 = self._generate_and_validate_metadata_record(metadata_standard_id=metadata_record_1['metadata_standard_id'], add_organization_to_model=True)
-        assert_metadata_model_has_dependent_records(metadata_model_1['id'], metadata_record_1['id'])
+        metadata_record_1, metadata_schema_1 = self._generate_and_validate_metadata_record(add_organization_to_schema=True)
+        metadata_record_2, metadata_schema_2 = self._generate_and_validate_metadata_record(metadata_standard_id=metadata_record_1['metadata_standard_id'], add_organization_to_schema=True)
+        assert_metadata_schema_has_dependent_records(metadata_schema_1['id'], metadata_record_1['id'])
 
-        result, obj = self.test_action('metadata_model_update',
-                                       id=metadata_model_1['id'],
-                                       metadata_standard_id=metadata_model_1['metadata_standard_id'],
+        result, obj = self.test_action('metadata_schema_update',
+                                       id=metadata_schema_1['id'],
+                                       metadata_standard_id=metadata_schema_1['metadata_standard_id'],
                                        organization_id='',
                                        infrastructure_id='',
-                                       model_json=json.dumps(metadata_model_1['model_json']))
+                                       schema_json=json.dumps(metadata_schema_1['schema_json']))
 
         assert_package_has_extra(metadata_record_1['id'], 'validated', True)
         assert_package_has_extra(metadata_record_2['id'], 'validated', False)
-        assert_metadata_model_has_dependent_records(metadata_model_1['id'], metadata_record_1['id'], metadata_record_2['id'])
-        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_model_update', obj)
+        assert_metadata_schema_has_dependent_records(metadata_schema_1['id'], metadata_record_1['id'], metadata_record_2['id'])
+        self.assert_invalidate_activity_logged(metadata_record_2['id'], 'metadata_schema_update', obj)
 
     def test_update_invalid_duplicate_name(self):
-        metadata_model1 = ckanext_factories.MetadataModel()
-        metadata_model2 = ckanext_factories.MetadataModel()
+        metadata_schema1 = ckanext_factories.MetadataSchema()
+        metadata_schema2 = ckanext_factories.MetadataSchema()
         input_dict = {
-            'id': metadata_model1['id'],
-            'name': metadata_model2['name'],
+            'id': metadata_schema1['id'],
+            'name': metadata_schema2['name'],
         }
-        result, obj = self.test_action('metadata_model_update', should_error=True, **input_dict)
-        assert_error(result, 'name', 'Duplicate name: Metadata Model')
+        result, obj = self.test_action('metadata_schema_update', should_error=True, **input_dict)
+        assert_error(result, 'name', 'Duplicate name: Metadata Schema')
 
     def test_update_invalid_missing_params(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'])
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'])
         assert_error(result, 'metadata_standard_id', 'Missing parameter')
         assert_error(result, 'organization_id', 'Missing parameter')
         assert_error(result, 'infrastructure_id', 'Missing parameter')
-        assert_error(result, 'model_json', 'Missing parameter')
+        assert_error(result, 'schema_json', 'Missing parameter')
 
     def test_update_invalid_missing_values(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'],
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'],
                                        metadata_standard_id='',
-                                       model_json='')
+                                       schema_json='')
         assert_error(result, 'metadata_standard_id', 'Missing value')
-        assert_error(result, 'model_json', 'Missing value')
+        assert_error(result, 'schema_json', 'Missing value')
 
     def test_update_invalid_duplicate_standard(self):
-        metadata_model1 = ckanext_factories.MetadataModel()
-        metadata_model2 = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model1['id'],
-                                       metadata_standard_id=metadata_model2['metadata_standard_id'])
+        metadata_schema1 = ckanext_factories.MetadataSchema()
+        metadata_schema2 = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema1['id'],
+                                       metadata_standard_id=metadata_schema2['metadata_standard_id'])
         assert_error(result, '__after', 'Unique constraint violation')
 
     def test_update_invalid_duplicate_standard_organization(self):
         organization = ckan_factories.Organization()
-        metadata_model1 = ckanext_factories.MetadataModel()
-        metadata_model2 = ckanext_factories.MetadataModel(organization_id=organization['id'])
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model1['id'],
-                                       metadata_standard_id=metadata_model2['metadata_standard_id'],
-                                       organization_id=metadata_model2['organization_id'])
+        metadata_schema1 = ckanext_factories.MetadataSchema()
+        metadata_schema2 = ckanext_factories.MetadataSchema(organization_id=organization['id'])
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema1['id'],
+                                       metadata_standard_id=metadata_schema2['metadata_standard_id'],
+                                       organization_id=metadata_schema2['organization_id'])
         assert_error(result, '__after', 'Unique constraint violation')
 
     def test_update_invalid_duplicate_standard_infrastructure(self):
         infrastructure = ckanext_factories.Infrastructure()
-        metadata_model1 = ckanext_factories.MetadataModel()
-        metadata_model2 = ckanext_factories.MetadataModel(infrastructure_id=infrastructure['id'])
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model1['id'],
-                                       metadata_standard_id=metadata_model2['metadata_standard_id'],
-                                       infrastructure_id=metadata_model2['infrastructure_id'])
+        metadata_schema1 = ckanext_factories.MetadataSchema()
+        metadata_schema2 = ckanext_factories.MetadataSchema(infrastructure_id=infrastructure['id'])
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema1['id'],
+                                       metadata_standard_id=metadata_schema2['metadata_standard_id'],
+                                       infrastructure_id=metadata_schema2['infrastructure_id'])
         assert_error(result, '__after', 'Unique constraint violation')
 
     def test_update_invalid_with_organization_set_infrastructure(self):
         organization = ckan_factories.Organization()
-        metadata_model = ckanext_factories.MetadataModel(organization_id=organization['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(organization_id=organization['id'])
         infrastructure = ckanext_factories.Infrastructure()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'],
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'],
                                        infrastructure_id=infrastructure['id'])
         assert_error(result, '__after',
-                     'A metadata model may be associated with either an organization or an infrastructure but not both.')
+                     'A metadata schema may be associated with either an organization or an infrastructure but not both.')
 
     def test_update_invalid_with_infrastructure_set_organization(self):
         infrastructure = ckanext_factories.Infrastructure()
-        metadata_model = ckanext_factories.MetadataModel(infrastructure_id=infrastructure['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(infrastructure_id=infrastructure['id'])
         organization = ckan_factories.Organization()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'],
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'],
                                        organization_id=organization['id'])
         assert_error(result, '__after',
-                     'A metadata model may be associated with either an organization or an infrastructure but not both.')
+                     'A metadata schema may be associated with either an organization or an infrastructure but not both.')
 
     def test_update_invalid_not_json(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'],
-                                       model_json='not json')
-        assert_error(result, 'model_json', 'JSON decode error')
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'],
+                                       schema_json='not json')
+        assert_error(result, 'schema_json', 'JSON decode error')
 
     def test_update_invalid_not_json_dict(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'],
-                                       model_json='[1,2,3]')
-        assert_error(result, 'model_json', 'Expecting a JSON dictionary')
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'],
+                                       schema_json='[1,2,3]')
+        assert_error(result, 'schema_json', 'Expecting a JSON dictionary')
 
     def test_update_invalid_not_json_schema(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'],
-                                       model_json='{"type": "foo"}')
-        assert_error(result, 'model_json', 'Invalid JSON schema')
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'],
+                                       schema_json='{"type": "foo"}')
+        assert_error(result, 'schema_json', 'Invalid JSON schema')
 
     def test_update_invalid_bad_references(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        result, obj = self.test_action('metadata_model_update', should_error=True,
-                                       id=metadata_model['id'],
+        metadata_schema = ckanext_factories.MetadataSchema()
+        result, obj = self.test_action('metadata_schema_update', should_error=True,
+                                       id=metadata_schema['id'],
                                        metadata_standard_id='a',
                                        organization_id='b',
                                        infrastructure_id='c')
@@ -731,7 +731,7 @@ def test_update_invalid_bad_references(self):
         assert_error(result, 'infrastructure_id', 'Not found: Infrastructure')
 
     def test_update_invalid_deleted_references(self):
-        metadata_model = ckanext_factories.MetadataModel()
+        metadata_schema = ckanext_factories.MetadataSchema()
         metadata_standard = ckanext_factories.MetadataStandard()
         organization = ckan_factories.Organization()
         infrastructure = ckanext_factories.Infrastructure()
@@ -739,8 +739,8 @@ def test_update_invalid_deleted_references(self):
         call_action('organization_delete', id=organization['id'])
         call_action('infrastructure_delete', id=infrastructure['id'])
 
-        result, obj = self.test_action('metadata_model_create', should_error=True,
-                                       id=metadata_model['id'],
+        result, obj = self.test_action('metadata_schema_create', should_error=True,
+                                       id=metadata_schema['id'],
                                        metadata_standard_id=metadata_standard['id'],
                                        organization_id=organization['id'],
                                        infrastructure_id=infrastructure['id'])
@@ -749,26 +749,26 @@ def test_update_invalid_deleted_references(self):
         assert_error(result, 'infrastructure_id', 'Not found: Infrastructure')
 
     def test_delete_valid(self):
-        metadata_model = ckanext_factories.MetadataModel()
-        self.test_action('metadata_model_delete',
-                         id=metadata_model['id'])
+        metadata_schema = ckanext_factories.MetadataSchema()
+        self.test_action('metadata_schema_delete',
+                         id=metadata_schema['id'])
 
     def test_delete_invalidate_records(self):
-        metadata_record, metadata_model = self._generate_and_validate_metadata_record()
-        result, obj = self.test_action('metadata_model_delete',
-                                       id=metadata_model['id'])
+        metadata_record, metadata_schema = self._generate_and_validate_metadata_record()
+        result, obj = self.test_action('metadata_schema_delete',
+                                       id=metadata_schema['id'])
         assert_package_has_extra(metadata_record['id'], 'validated', False)
-        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_model_delete', obj)
+        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_schema_delete', obj)
 
-        metadata_record, metadata_model = self._generate_and_validate_metadata_record(add_organization_to_model=True)
-        result, obj = self.test_action('metadata_model_delete',
-                                       id=metadata_model['id'])
+        metadata_record, metadata_schema = self._generate_and_validate_metadata_record(add_organization_to_schema=True)
+        result, obj = self.test_action('metadata_schema_delete',
+                                       id=metadata_schema['id'])
         assert_package_has_extra(metadata_record['id'], 'validated', False)
-        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_model_delete', obj)
+        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_schema_delete', obj)
 
-        metadata_record, metadata_model = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True,
-                                                                                      add_infrastructure_to_model=True)
-        result, obj = self.test_action('metadata_model_delete',
-                                       id=metadata_model['id'])
+        metadata_record, metadata_schema = self._generate_and_validate_metadata_record(add_infrastructure_to_record=True,
+                                                                                      add_infrastructure_to_schema=True)
+        result, obj = self.test_action('metadata_schema_delete',
+                                       id=metadata_schema['id'])
         assert_package_has_extra(metadata_record['id'], 'validated', False)
-        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_model_delete', obj)
+        self.assert_invalidate_activity_logged(metadata_record['id'], 'metadata_schema_delete', obj)
diff --git a/ckanext/metadata/tests/test_metadata_standard_actions.py b/ckanext/metadata/tests/test_metadata_standard_actions.py
index 1a84f59..07abe9d 100644
--- a/ckanext/metadata/tests/test_metadata_standard_actions.py
+++ b/ckanext/metadata/tests/test_metadata_standard_actions.py
@@ -300,16 +300,16 @@ def test_delete_with_child_standards(self):
 
     def test_delete_with_dependencies(self):
         metadata_standard = ckanext_factories.MetadataStandard()
-        metadata_model = ckanext_factories.MetadataModel(metadata_standard_id=metadata_standard['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(metadata_standard_id=metadata_standard['id'])
         metadata_record = ckanext_factories.MetadataRecord(metadata_standard_id=metadata_standard['id'])
 
         result, obj = self.test_action('metadata_standard_delete', should_error=True,
                                        id=metadata_standard['id'])
 
         assert_error(result, 'message', 'Metadata standard has dependent metadata records')
-        assert ckanext_model.MetadataModel.get(metadata_model['id']).state == 'active'
+        assert ckanext_model.MetadataSchema.get(metadata_schema['id']).state == 'active'
 
         call_action('metadata_record_delete', id=metadata_record['id'])
         self.test_action('metadata_standard_delete',
                          id=metadata_standard['id'])
-        assert ckanext_model.MetadataModel.get(metadata_model['id']).state == 'deleted'
+        assert ckanext_model.MetadataSchema.get(metadata_schema['id']).state == 'deleted'
diff --git a/ckanext/metadata/tests/test_organization_actions.py b/ckanext/metadata/tests/test_organization_actions.py
index fcf8a87..c55158a 100644
--- a/ckanext/metadata/tests/test_organization_actions.py
+++ b/ckanext/metadata/tests/test_organization_actions.py
@@ -25,13 +25,13 @@ def test_delete_valid(self):
         self.test_action('organization_delete',
                          id=organization['id'])
 
-    def test_delete_valid_cascade_metadata_models(self):
+    def test_delete_valid_cascade_metadata_schemas(self):
         organization = self._generate_organization()
-        metadata_model = ckanext_factories.MetadataModel(organization_id=organization['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(organization_id=organization['id'])
 
         self.test_action('organization_delete',
                          id=organization['id'])
-        assert ckanext_model.MetadataModel.get(metadata_model['id']).state == 'deleted'
+        assert ckanext_model.MetadataSchema.get(metadata_schema['id']).state == 'deleted'
 
     def test_delete_valid_cascade_metadata_collections(self):
         organization = self._generate_organization()
@@ -44,7 +44,7 @@ def test_delete_valid_cascade_metadata_collections(self):
     def test_delete_with_dependencies(self):
         organization = self._generate_organization()
         metadata_collection = self._generate_metadata_collection(organization_id=organization['id'])
-        metadata_model = ckanext_factories.MetadataModel(organization_id=organization['id'])
+        metadata_schema = ckanext_factories.MetadataSchema(organization_id=organization['id'])
         metadata_record = ckanext_factories.MetadataRecord(owner_org=organization['id'],
                                                            metadata_collection_id=metadata_collection['id'])
 
@@ -52,10 +52,10 @@ def test_delete_with_dependencies(self):
                                        id=organization['id'])
         assert_error(result, 'message', 'Organization has dependent metadata records')
         assert ckan_model.Group.get(metadata_collection['id']).state == 'active'
-        assert ckanext_model.MetadataModel.get(metadata_model['id']).state == 'active'
+        assert ckanext_model.MetadataSchema.get(metadata_schema['id']).state == 'active'
 
         call_action('metadata_record_delete', id=metadata_record['id'])
         self.test_action('organization_delete',
                          id=organization['id'])
         assert ckan_model.Group.get(metadata_collection['id']).state == 'deleted'
-        assert ckanext_model.MetadataModel.get(metadata_model['id']).state == 'deleted'
+        assert ckanext_model.MetadataSchema.get(metadata_schema['id']).state == 'deleted'
diff --git a/examples/saeon_datacite_model.json b/examples/saeon_datacite_schema.json
similarity index 100%
rename from examples/saeon_datacite_model.json
rename to examples/saeon_datacite_schema.json