diff --git a/control/types.hpp b/control/types.hpp
new file mode 100644
index 0000000..e4c3725
--- /dev/null
+++ b/control/types.hpp
@@ -0,0 +1,34 @@
+#pragma once
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace phosphor
+{
+namespace fan
+{
+namespace control
+{
+
+//Placeholder. Conditions are completely TBD.
+using Condition = bool;
+
+constexpr auto fanNamePos = 0;
+constexpr auto sensorListPos = 1;
+using FanDefinition = std::tuple<std::string, std::vector<std::string>>;
+
+constexpr auto zoneNumPos = 0;
+constexpr auto fullSpeedPos = 1;
+constexpr auto fanListPos = 2;
+using ZoneDefinition = std::tuple<size_t,
+                                  unsigned int,
+                                  std::vector<FanDefinition>>;
+
+constexpr auto conditionListPos = 0;
+constexpr auto zoneListPos = 1;
+using ZoneGroup = std::tuple<std::vector<Condition>,
+                             std::vector<ZoneDefinition>>;
+
+}
+}
+}
