diff --git a/reclass/datatypes/parameters.py b/reclass/datatypes/parameters.py
index 6fcdd6e..711db88 100644
--- a/reclass/datatypes/parameters.py
+++ b/reclass/datatypes/parameters.py
@@ -227,14 +227,14 @@
         for n, value in enumerate(item_list):
             self._render_simple_container(item_list, n, value, path)
 
-    def interpolate(self, exports=None):
+    def interpolate(self, inventory=None):
         self._initialise_interpolate(self._options)
         while len(self._unrendered) > 0:
             # we could use a view here, but this is simple enough:
             # _interpolate_inner removes references from the refs hash after
             # processing them, so we cannot just iterate the dict
             path, v = self._unrendered.iteritems().next()
-            self._interpolate_inner(path, exports)
+            self._interpolate_inner(path, inventory)
 
     def initialise_interpolation(self, options=None):
         self._unrendered = None
@@ -251,7 +251,7 @@
             self._has_inv_query = False
             self._render_simple_dict(self._base, DictPath(self._delimiter))
 
-    def _interpolate_inner(self, path, exports):
+    def _interpolate_inner(self, path, inventory):
         value = path.get_value(self._base)
         if not isinstance(value, (Value, ValueList)):
             # references to lists and dicts are only deepcopied when merged
@@ -260,14 +260,14 @@
             del self._unrendered[path]
             return
         self._unrendered[path] = False
-        self._interpolate_references(path, value, exports)
-        new = self._interpolate_render_value(path, value, exports)
+        self._interpolate_references(path, value, inventory)
+        new = self._interpolate_render_value(path, value, inventory)
         path.set_value(self._base, new)
         del self._unrendered[path]
 
-    def _interpolate_render_value(self, path, value, exports):
+    def _interpolate_render_value(self, path, value, inventory):
         try:
-            new = value.render(self._base, exports, self._options)
+            new = value.render(self._base, inventory, self._options)
         except UndefinedVariableError as e:
             raise UndefinedVariableError(e.var, path)
 
@@ -277,7 +277,7 @@
             self._render_simple_list(new, path)
         return new
 
-    def _interpolate_references(self, path, value, exports):
+    def _interpolate_references(self, path, value, inventory):
         all_refs = False
         while not all_refs:
             for ref in value.get_references():
@@ -292,14 +292,14 @@
                         # faced with a cyclical reference.
                         raise InfiniteRecursionError(path, ref)
                     else:
-                        self._interpolate_inner(path_from_ref, exports)
+                        self._interpolate_inner(path_from_ref, inventory)
                 else:
                     # ensure ancestor keys are already dereferenced
                     ancestor = DictPath(self._delimiter)
                     for k in path_from_ref.key_parts():
                         ancestor = ancestor.new_subpath(k)
                         if ancestor in self._unrendered:
-                            self._interpolate_inner(ancestor, exports)
+                            self._interpolate_inner(ancestor, inventory)
             if value.allRefs():
                 all_refs = True
             else:
diff --git a/reclass/values/compitem.py b/reclass/values/compitem.py
index 8a22376..ea342a5 100644
--- a/reclass/values/compitem.py
+++ b/reclass/values/compitem.py
@@ -37,12 +37,12 @@
     def get_references(self):
         return self._refs
 
-    def render(self, context, exports):
+    def render(self, context, inventory):
         # Preserve type if only one item
         if len(self._items) == 1:
-            return self._items[0].render(context, exports)
+            return self._items[0].render(context, inventory)
         # Multiple items
-        strings = [ str(i.render(context, exports)) for i in self._items ]
+        strings = [ str(i.render(context, inventory)) for i in self._items ]
         return "".join(strings)
 
     def __repr__(self):
diff --git a/reclass/values/dictitem.py b/reclass/values/dictitem.py
index 1689aed..bc58f67 100644
--- a/reclass/values/dictitem.py
+++ b/reclass/values/dictitem.py
@@ -26,7 +26,7 @@
                 raise TypeError('allow dict over scalar = False: cannot merge %s onto %s' % (repr(self), repr(item)))
         raise TypeError('Cannot merge %s over %s' % (repr(self), repr(item)))
 
-    def render(self, context, exports):
+    def render(self, context, inventory):
         return self._dict
 
     def __repr__(self):
diff --git a/reclass/values/invitem.py b/reclass/values/invitem.py
index 36fa9a2..0841a44 100644
--- a/reclass/values/invitem.py
+++ b/reclass/values/invitem.py
@@ -122,15 +122,15 @@
         except KeyError as e:
             raise UndefinedVariableError(str(path))
 
-    def _value_expression(self, exports):
+    def _value_expression(self, inventory):
         results = {}
         path = DictPath(self._delimiter, self._expr[0][1]).drop_first()
-        for node, items in exports.iteritems():
+        for node, items in inventory.iteritems():
             if path.exists_in(items):
                 results[node] = copy.deepcopy(self._resolve(path, items))
         return results
 
-    def _test_expression(self, context, exports):
+    def _test_expression(self, context, inventory):
         export_path = None
         parameter_path = None
         parameter_value = None
@@ -156,7 +156,7 @@
         value_path.drop_first()
 
         results = {}
-        for node, items in exports.iteritems():
+        for node, items in inventory.iteritems():
             if export_path.exists_in(items):
                 export_value = self._resolve(export_path, items)
                 test_passed = False
@@ -181,11 +181,11 @@
             value = var
         return export, parameter, value
 
-    def render(self, context, exports):
+    def render(self, context, inventory):
         if self._expr_type == _VALUE:
-            return self._value_expression(exports)
+            return self._value_expression(inventory)
         elif self._expr_type == _TEST:
-            return self._test_expression(context, exports)
+            return self._test_expression(context, inventory)
         raise ExpressionError('Failed to render %s' % str(self))
 
     def __str__(self):
diff --git a/reclass/values/listitem.py b/reclass/values/listitem.py
index 06f1e10..ede8251 100644
--- a/reclass/values/listitem.py
+++ b/reclass/values/listitem.py
@@ -18,7 +18,7 @@
     def is_container(self):
         return True
 
-    def render(self, context, exports):
+    def render(self, context, inventory):
         return self._list
 
     def merge_over(self, item, options):
diff --git a/reclass/values/refitem.py b/reclass/values/refitem.py
index c2a2618..b97780a 100644
--- a/reclass/values/refitem.py
+++ b/reclass/values/refitem.py
@@ -53,10 +53,10 @@
         except KeyError as e:
             raise UndefinedVariableError(ref)
 
-    def render(self, context, exports):
+    def render(self, context, inventory):
         if len(self._items) == 1:
-            return self._resolve(self._items[0].render(context, exports), context)
-        strings = [ str(i.render(context, exports)) for i in self._items ]
+            return self._resolve(self._items[0].render(context, inventory), context)
+        strings = [ str(i.render(context, inventory)) for i in self._items ]
         return self._resolve("".join(strings), context)
 
     def __repr__(self):
diff --git a/reclass/values/scaitem.py b/reclass/values/scaitem.py
index a1a5a21..151e123 100644
--- a/reclass/values/scaitem.py
+++ b/reclass/values/scaitem.py
@@ -30,7 +30,7 @@
                 raise TypeError('allow scalar over dict = False: cannot merge %s over %s' % (repr(self), repr(item)))
         raise TypeError('Cannot merge %s over %s' % (repr(self), repr(item)))
 
-    def render(self, context, exports):
+    def render(self, context, inventory):
         return self._value
 
     def __repr__(self):
diff --git a/reclass/values/value.py b/reclass/values/value.py
index e0cfa08..355aab2 100644
--- a/reclass/values/value.py
+++ b/reclass/values/value.py
@@ -47,8 +47,8 @@
         if self._item.has_references():
             self._item.assembleRefs(context)
 
-    def render(self, context, exports, options=None):
-        return self._item.render(context, exports)
+    def render(self, context, inventory, options=None):
+        return self._item.render(context, inventory)
 
     def contents(self):
         return self._item.contents()
diff --git a/reclass/values/valuelist.py b/reclass/values/valuelist.py
index 780eedd..38f782c 100644
--- a/reclass/values/valuelist.py
+++ b/reclass/values/valuelist.py
@@ -68,17 +68,17 @@
                 output = value.merge_over(output, options)
         return output
 
-    def render(self, context, exports, options):
+    def render(self, context, inventory, options):
         from reclass.datatypes.parameters import Parameters
 
         output = None
         deepCopied = False
         for n, value in enumerate(self._values):
             if output is None:
-                output = self._values[n].render(context, exports, options)
+                output = self._values[n].render(context, inventory)
                 deepCopied = False
             else:
-                new = value.render(context, exports, options)
+                new = value.render(context, inventory)
                 if isinstance(output, dict) and isinstance(new, dict):
                     p1 = Parameters(output, value._delimiter)
                     p2 = Parameters(new, value._delimiter)