do not merge - hack for exporting gridlines - each edge is a separate polyline

WIP
2024-10-31 18:15:08 +01:00 · 2024-10-31 13:09:35 +01:00
85 changed files with 455 additions and 4226 deletions
@@ -3,7 +3,6 @@ build/
 Documents/
 ResourceObjects/
 Install/
-enc_temp_folder/
 .vs/
 .vscode/
 xcuserdata/
@@ -94,7 +94,6 @@
  <ItemGroup>
    <ClCompile Include="Connector\Connector.cpp" />
    <ClCompile Include="Connector\Database\ModelCardDatabase.cpp" />
-    <ClCompile Include="Connector\Environment\ConnectorProject.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Account\AccountBridge.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Account\GetAccounts.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\AddModel.cpp" />
@@ -151,7 +150,6 @@
    <ClInclude Include="Connector\ConnectorResource.h" />
    <ClInclude Include="Connector\Database\Identity\RecordID.h" />
    <ClInclude Include="Connector\Database\ModelCardDatabase.h" />
-    <ClInclude Include="Connector\Environment\ConnectorProject.h" />
    <ClInclude Include="Connector\Event\ConnectorEventID.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Account\AccountBridge.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Account\GetAccounts.h" />
@@ -71,9 +71,6 @@
    <Filter Include="Connector\Interface\Browser\Bridge\Selection\Arg">
      <UniqueIdentifier>{8bb3df60-affe-4b66-8d78-f1b98e6ba8df}</UniqueIdentifier>
    </Filter>
-    <Filter Include="Connector\Environment">
-      <UniqueIdentifier>{1d9a10c3-cac6-4b15-afb9-f117b99b3a24}</UniqueIdentifier>
-    </Filter>
  </ItemGroup>
  <ItemGroup>
    <None Include="RFIX.win\Connector.rc2">
@@ -252,9 +249,6 @@
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\OpenUrl.cpp">
      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
    </ClCompile>
-    <ClCompile Include="Connector\Environment\ConnectorProject.cpp">
-      <Filter>Connector\Environment</Filter>
-    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Connector\ConnectorResource.h">
@@ -429,8 +423,5 @@
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\OpenUrl.h">
      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
    </ClInclude>
-    <ClInclude Include="Connector\Environment\ConnectorProject.h">
-      <Filter>Connector\Environment</Filter>
-    </ClInclude>
  </ItemGroup>
 </Project>
@@ -31,7 +31,6 @@
 		215F08372C95808B00CD343B /* ReceiverModelCard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08362C95808B00CD343B /* ReceiverModelCard.cpp */; };
 		215F08462C9633A800CD343B /* EverythingSendFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08452C9633A800CD343B /* EverythingSendFilter.cpp */; };
 		2192460D2CA3469D00CF5703 /* ProjectCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2192460B2CA3469D00CF5703 /* ProjectCollection.cpp */; };
-		2199BB552CDA4B1700A4BEEC /* ConnectorProject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2199BB522CDA4B1700A4BEEC /* ConnectorProject.cpp */; };
 		219F30422C769283009834E9 /* ConfigTests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219F30402C769282009834E9 /* ConfigTests.cpp */; };
 		21A0FB982CB723240023F24E /* FinishProxy.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21A0FB942CB723240023F24E /* FinishProxy.cpp */; };
 		21A79EC92CCDA45C001754E4 /* HighlightModel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21A79EC52CCDA45C001754E4 /* HighlightModel.cpp */; };
@@ -317,10 +316,6 @@
 		2192460B2CA3469D00CF5703 /* ProjectCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProjectCollection.cpp; sourceTree = "<group>"; };
 		2192460C2CA3469D00CF5703 /* ProjectCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ProjectCollection.h; sourceTree = "<group>"; };
 		219388682C4E5DE2002A0180 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
-		2199BB512CDA481A00A4BEEC /* ConnectorFix.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorFix.grc; path = RFIX/ConnectorFix.grc; sourceTree = "<group>"; };
-		2199BB522CDA4B1700A4BEEC /* ConnectorProject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ConnectorProject.cpp; sourceTree = "<group>"; };
-		2199BB532CDA4B1700A4BEEC /* ConnectorProject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConnectorProject.h; sourceTree = "<group>"; };
-		2199BB5C2CDA93CE00A4BEEC /* ConnectorImagesFix.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorImagesFix.grc; path = RFIX/ConnectorImagesFix.grc; sourceTree = "<group>"; };
 		219F30352C768F0A009834E9 /* Connector-AC27-Test.bundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "Connector-AC27-Test.bundle"; sourceTree = BUILT_PRODUCTS_DIR; };
 		219F30402C769282009834E9 /* ConfigTests.cpp */ = {isa = PBXFileReference; explicitFileType = sourcecode.cpp.objcpp; fileEncoding = 4; path = ConfigTests.cpp; sourceTree = "<group>"; };
 		219F30432C7693B6009834E9 /* Connector-AC27-Debug.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; path = "Connector-AC27-Debug.xctestplan"; sourceTree = SOURCE_ROOT; };
@@ -553,6 +548,7 @@
 		21D1E9AC2BF14AF200957EAA /* TeamworkProductVersion.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = TeamworkProductVersion.framework; path = "../Archicad 27/Support/Frameworks/TeamworkProductVersion.framework"; sourceTree = "<group>"; };
 		21D1EA452BF14B0700957EAA /* VWMM.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = VWMM.framework; path = "../Vectorworks 2024/SDKLib/LibMac/Release/VWMM.framework"; sourceTree = "<group>"; };
 		21D1EA4A2BF14BBC00957EAA /* Connector.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = Connector.grc; path = RINT/Connector.grc; sourceTree = "<group>"; };
+		21D1EA4B2BF14BC700957EAA /* ConnectorFix.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorFix.grc; path = RFIX/ConnectorFix.grc; sourceTree = "<group>"; };
 		21D1EA4C2BF14BF000957EAA /* Module-Info27.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = "Module-Info27.plist"; path = "RINT.Archicad/EN-GB/Module-Info27.plist"; sourceTree = "<group>"; };
 		21F69EC62C64C035008B6A06 /* SpeckleLib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = SpeckleLib.xcodeproj; path = ../SpeckleLib/SpeckleLib.xcodeproj; sourceTree = "<group>"; };
 		21F69EDB2C64ED10008B6A06 /* ConnectorMenu.grc */ = {isa = PBXFileReference; lastKnownFileType = text; name = ConnectorMenu.grc; path = RINT/ConnectorMenu.grc; sourceTree = "<group>"; };
@@ -972,24 +968,6 @@
 			path = Identity;
 			sourceTree = "<group>";
 		};
-		2199BB4E2CDA47F900A4BEEC /* Fixed */ = {
-			isa = PBXGroup;
-			children = (
-				2199BB512CDA481A00A4BEEC /* ConnectorFix.grc */,
-				2199BB5C2CDA93CE00A4BEEC /* ConnectorImagesFix.grc */,
-			);
-			name = Fixed;
-			sourceTree = "<group>";
-		};
-		2199BB542CDA4B1700A4BEEC /* Environment */ = {
-			isa = PBXGroup;
-			children = (
-				2199BB522CDA4B1700A4BEEC /* ConnectorProject.cpp */,
-				2199BB532CDA4B1700A4BEEC /* ConnectorProject.h */,
-			);
-			path = Environment;
-			sourceTree = "<group>";
-		};
 		219F30412C769282009834E9 /* ConnectorTests */ = {
 			isa = PBXGroup;
 			children = (
@@ -1185,6 +1163,7 @@
 			isa = PBXGroup;
 			children = (
 				21D1EA4A2BF14BBC00957EAA /* Connector.grc */,
+				21D1EA4B2BF14BC700957EAA /* ConnectorFix.grc */,
 				21F69EDB2C64ED10008B6A06 /* ConnectorMenu.grc */,
 				21D1EA4C2BF14BF000957EAA /* Module-Info27.plist */,
 				21F69EFE2C66AD55008B6A06 /* SpecklePalette.grc */,
@@ -1237,7 +1216,6 @@
 				21B67CCD2C77694500FD64FC /* Connector.h */,
 				21F69F102C677BC0008B6A06 /* ConnectorResource.h */,
 				21B67CCB2C77670400FD64FC /* Database */,
-				2199BB542CDA4B1700A4BEEC /* Environment */,
 				21F69F092C677BC0008B6A06 /* Event */,
 				21F69F0E2C677BC0008B6A06 /* Interface */,
 				21D0BDD82C9387E60077E104 /* Record */,
@@ -1318,7 +1296,6 @@
 		81494D9D09DA5892006864FB /* Resource */ = {
 			isa = PBXGroup;
 			children = (
-				2199BB4E2CDA47F900A4BEEC /* Fixed */,
 				7EA5F91E157FA18400693CEA /* EN-GB */,
 			);
 			name = Resource;
@@ -1553,7 +1530,6 @@
 				215F08372C95808B00CD343B /* ReceiverModelCard.cpp in Sources */,
 				21D0BDD72C935DAE0077E104 /* RemoveModel.cpp in Sources */,
 				21A890BC2CC15C540087E732 /* SelectionInfo.cpp in Sources */,
-				2199BB552CDA4B1700A4BEEC /* ConnectorProject.cpp in Sources */,
 				21AEF9EF2CAB5720000B8681 /* SendObject.cpp in Sources */,
 				21384BCD2CD2EE7400D4602B /* OpenUrl.cpp in Sources */,
 				21B67CDC2C78C88000FD64FC /* SayHi.cpp in Sources */,
@@ -1,7 +1,7 @@
 #include "Active/File/Directory.h"
 #include "ConnectorResource.h"
 #include "Connector/Connector.h"
-#include "Connector/Environment/ConnectorProject.h"
+#include "Connector/Database/ModelCardDatabase.h"
 #include "Connector/Interface/ConnectorMenu.h"
 #include "Connector/Interface/ConnectorPalette.h"
 #include "Speckle/Database/AccountDatabase.h"
@@ -11,7 +11,7 @@
 using namespace active::file;
 using namespace active::environment;
 using namespace connector;
-using namespace connector::environment;
+using namespace connector::database;
 using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::utility;
@@ -29,6 +29,8 @@ namespace {
 		ConnectorInstance(const String& name) : ConnectorAddon{name} {
 			add<ConnectorMenu>();
 			add<ConnectorPalette>();
+				//The connector 'owns' the model card database, so the publisher list should only hold a weak reference
+			addWeak(m_modelCards.getSubscription());
 		}
 		
 		// MARK: Functions (const)
@@ -38,18 +40,15 @@ namespace {
 		 @return The account database
 		 */
 		const AccountDatabase* getAccountDatabase() const override;
-		
-	protected:
 		/*!
-		 Make a new new project. Allows Addon subclasses to define a Project subclass with additional functions/databases
-		 @return A new project instance
+		 Get the model card database
+		 @return The model card database
 		 */
-		virtual std::shared_ptr<Project> makeProject() const override {
-			return std::dynamic_pointer_cast<Project>(std::make_shared<ConnectorProject>());
-		}
+		const ModelCardDatabase* getModelCardDatabase() const override { return &m_modelCards; }
 		
 	private:
 		mutable std::unique_ptr<AccountDatabase> m_account;
+		ModelCardDatabase m_modelCards;
 	};
 	
 		///The active addon instance
@@ -3,6 +3,10 @@

 namespace speckle::database {
 	class AccountDatabase;
+	class BIMElementDatabase;
+}
+namespace connector::database {
+	class ModelCardDatabase;
 }

 namespace connector {
@@ -18,6 +22,11 @@ namespace connector {
 		 @return The account database
 		 */
 		const virtual speckle::database::AccountDatabase* getAccountDatabase() const = 0;
+		/*!
+		 Get the model card database
+		 @return The model card database
+		 */
+		const virtual database::ModelCardDatabase* getModelCardDatabase() const = 0;
 		
 	protected:
 		/*!
@@ -1,33 +0,0 @@
-#include "Connector/Environment/ConnectorProject.h"
-
-#include "Connector/Connector.h"
-#include "Connector/Database/ModelCardDatabase.h"
-
-using namespace active::event;
-using namespace connector::database;
-using namespace connector::environment;
-using namespace speckle::utility;
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-ConnectorProject::ConnectorProject() {
-	m_modelCards = std::make_shared<ModelCardDatabase>();
-	connector()->addWeak(m_modelCards->getSubscription());
-}
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-ConnectorProject::~ConnectorProject() {}
-
-
-/*--------------------------------------------------------------------
-	Get the model card database
- 
-	return; The model card database
-  --------------------------------------------------------------------*/
-const ModelCardDatabase* ConnectorProject::getModelCardDatabase() const {
-	return m_modelCards.get();
-} //ConnectorProject::getModelCardDatabase
@@ -1,53 +0,0 @@
-#ifndef CONNECTOR_ENVIRONMENT_CONNECTOR_PROJECT
-#define CONNECTOR_ENVIRONMENT_CONNECTOR_PROJECT
-
-#include "Speckle/Environment/Project.h"
-
-namespace connector::database {
-	class ModelCardDatabase;
-}
-
-namespace connector::environment {
-	
-	/*!
-	 A BIM project contained Speckle connector data, e.g. a model card database
-	*/
-	class ConnectorProject : public speckle::environment::Project {
-	public:
-
-		// MARK: - Types
-		
-			///Shared pointer
-		using Shared = std::shared_ptr<ConnectorProject>;
-			///Weak pointer
-		using Weak = std::weak_ptr<ConnectorProject>;
-
-		// MARK: - Constructors
-		
-		/*!
-		 Default constructor
-		 */
-		ConnectorProject();
-		
-		ConnectorProject(const ConnectorProject&) = delete;
-		/*!
-		 Destructor
-		 */
-		~ConnectorProject();
-		
-		// MARK: - Functions (const)
-		
-		/*!
-		 Get the model card database
-		 @return The model card database
-		 */
-		const connector::database::ModelCardDatabase* getModelCardDatabase() const;
-		
-	private:
-			///The model card database
-		std::shared_ptr<connector::database::ModelCardDatabase> m_modelCards;
-	};
-
-}
-
-#endif	//CONNECTOR_ENVIRONMENT_CONNECTOR_PROJECT
@@ -1,12 +1,10 @@
 #include "Connector/Interface/Browser/Bridge/Base/AddModel.h"

 #include "Connector/Connector.h"
-#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"

 using namespace active::container;
 using namespace active::serialise;
-using namespace connector::environment;
 using namespace connector::record;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;
@@ -25,10 +23,6 @@ AddModel::AddModel() : BridgeMethod{"AddModel", [&](const ModelCardEventWrapper&
 	card: The card to add
  --------------------------------------------------------------------*/
 void AddModel::run(const ModelCard& card) const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return;
-	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr)
+	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr)
 		modelCardDBase->write(card);
 } //AddModel::run
@@ -11,37 +11,8 @@
 #include "Connector/Interface/Browser/Bridge/Base/OpenUrl.h"
 #include "Speckle/Event/Type/ProjectEvent.h"

-#include "Speckle/Environment/Project.h"
-#include "Speckle/Record/Element/Element.h"
-#include "Connector/Connector.h"
-#include "Connector/ConnectorResource.h"
-#include "Speckle/Database/Identity/RecordID.h"
-#include "Speckle/Database/BIMElementDatabase.h"
-#include "Connector/Record/Model/SenderModelCard.h"
-#include "Connector/Record/Model/Filter/SendFilter.h"
-#include "Connector/Database/ModelCardDatabase.h"
-
 using namespace connector::interfac::browser::bridge;

-namespace {
-#ifdef ARCHICAD
-	void subscribeAllElementsToElementChangeEvents()
-	{
-		auto project = connector::connector()->getActiveProject().lock();
-		if (!project)
-			return;
-
-		auto elementDatabase = project->getElementDatabase();
-		//auto table = elementDatabase->getTables(speckle::database::ElementStorage::TableType::primary2D);
-		//auto allElements = elementDatabase->findElements(nullptr, *table.begin());
-		auto allElements = elementDatabase->findElements();
-
-		for (const auto& id : allElements)
-			ACAPI_Element_AttachObserver(id);
-	}
-#endif
-}
-
 /*--------------------------------------------------------------------
 	Default constructor
  --------------------------------------------------------------------*/
@@ -57,10 +28,6 @@ BaseBridge::BaseBridge() : BrowserBridge{"baseBinding"} {
 	addMethod<UpdateModel>();
 	addMethod<HighlightModel>();
 	addMethod<OpenUrl>();
-
-	// POC: Attaching Observer to all elements is too slow, registration is commented out for now
-	// subscribeAllElementsToElementChangeEvents();
-
 } //BaseBridge::BaseBridge

 /*--------------------------------------------------------------------
@@ -73,11 +40,9 @@ BaseBridge::BaseBridge() : BrowserBridge{"baseBinding"} {
 bool BaseBridge::handle(const speckle::event::ProjectEvent& event) {
 	using enum speckle::event::ProjectEvent::Type;
 	switch (event.getType()) {
-		case open: {
+		case open:
 			sendEvent("documentChanged");
-			// POC: Attaching Observer to all elements is too slow, registration is commented out for now
-			// subscribeAllElementsToElementChangeEvents();
-		} break;
+			break;
 		default:
 			break;
 	}
@@ -2,7 +2,6 @@

 #include "Active/Serialise/CargoHold.h"
 #include "Connector/Connector.h"
-#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"
 #include "Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h"
 #include "Speckle/Environment/Project.h"
@@ -10,7 +9,6 @@

 using namespace active::container;
 using namespace active::serialise;
-using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;

@@ -35,17 +33,14 @@ GetDocumentInfo::GetDocumentInfo() : BridgeMethod{"GetDocumentInfo", [&]() {
  --------------------------------------------------------------------*/
 std::unique_ptr<Cargo> GetDocumentInfo::run() const {
 	auto docInfo = std::make_unique<DocumentInfo>();
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return nullptr;
-	auto info = connectorProject->getInfo();
-	docInfo->name = info.name;
-	if (info.path)
-		docInfo->location = *info.path;
-	if (auto cardDatabase = connectorProject->getModelCardDatabase(); cardDatabase != nullptr)
-		docInfo->ID = cardDatabase->getStoreID();
-	else
+	if (auto project = connector()->getActiveProject().lock(); project) {
+		auto info = project->getInfo();
+		docInfo->name = info.name;
+		if (info.path)
+			docInfo->location = *info.path;
+		if (auto cardDatabase = connector()->getModelCardDatabase(); cardDatabase != nullptr)
+			docInfo->ID = cardDatabase->getStoreID();
 		docInfo->ID = Guid{true}.operator String();
+	}
 	return std::make_unique<WrappedValue>(std::move(docInfo));
 } //GetDocumentInfo::run
@@ -1,13 +1,15 @@
 #include "Connector/Interface/Browser/Bridge/Base/GetDocumentState.h"

+#include "Active/Serialise/CargoHold.h"
 #include "Connector/Connector.h"
-#include "Connector/Environment/ConnectorProject.h"
+#include "Connector/Record/Model/ModelCard.h"
 #include "Connector/Database/ModelCardDatabase.h"

 using namespace active::container;
 using namespace active::serialise;
-using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
+using namespace connector::database;
+using namespace connector::record;
 using namespace speckle::utility;

 /*--------------------------------------------------------------------
@@ -24,11 +26,7 @@ GetDocumentState::GetDocumentState() : BridgeMethod{"GetDocumentState", [&]() {
 	return: The document model cards
  --------------------------------------------------------------------*/
 std::unique_ptr<Cargo> GetDocumentState::run() const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return nullptr;
-	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr) {
+	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr) {
 		return modelCardDBase->wrapper();
 	}
 	return nullptr;
@@ -1,7 +1,6 @@
 #include "Connector/Interface/Browser/Bridge/Base/HighlightModel.h"
 #include "Connector/Connector.h"
 #include "Connector/ConnectorResource.h"
-#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
 #include "Connector/Record/Model/SenderModelCard.h"
@@ -12,7 +11,6 @@
 #include "Speckle/Environment/Project.h"

 using namespace speckle::record::element;
-using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace connector::record;
 using namespace speckle::utility;
@@ -31,12 +29,8 @@ HighlightModel::HighlightModel() : BridgeMethod{"HighlightModel", [&](const Send
 	modelCardID: The ID of the target model card
  --------------------------------------------------------------------*/
 void HighlightModel::run(const String& modelCardID) const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return;
-		//Find the specified model card
-	auto modelCardDatabase = connectorProject->getModelCardDatabase();
+	// Find the specified model card
+	auto modelCardDatabase = connector()->getModelCardDatabase();
 	auto modelCard = modelCardDatabase->getCard(modelCardID);
 	if (!modelCard) {
 		getBridge()->sendEvent("setModelError",
@@ -1,16 +1,22 @@
 #include "Connector/Interface/Browser/Bridge/Base/RemoveModel.h"

 #include "Connector/Connector.h"
-#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Database/ModelCardDatabase.h"
+#include "Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h"

 using namespace active::container;
 using namespace active::serialise;
-using namespace connector::environment;
+using namespace connector::database;
 using namespace connector::record;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;

+namespace {
+	
+	using WrappedValue = active::serialise::CargoHold<PackageWrap, DocumentInfo>;
+
+}
+
 /*--------------------------------------------------------------------
 	Default constructor
  --------------------------------------------------------------------*/
@@ -25,10 +31,6 @@ RemoveModel::RemoveModel() : BridgeMethod{"RemoveModel", [&](const ModelCardEven
 	card: The card to add
  --------------------------------------------------------------------*/
 void RemoveModel::run(const ModelCard& card) const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return;
-	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr)
+	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr)
 		modelCardDBase->erase(card.getID());
 } //RemoveModel::run
@@ -2,12 +2,11 @@

 #include "Connector/Connector.h"
 #include "Connector/Database/ModelCardDatabase.h"
-#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h"

 using namespace active::container;
 using namespace active::serialise;
-using namespace connector::environment;
+using namespace connector::database;
 using namespace connector::record;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;
@@ -32,10 +31,6 @@ UpdateModel::UpdateModel() : BridgeMethod{"UpdateModel", [&](const ModelCardEven
 	card: The card to update
  --------------------------------------------------------------------*/
 void UpdateModel::run(const ModelCard& card) const {
-	auto project = connector()->getActiveProject().lock();
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return;
-	if (auto modelCardDBase = connectorProject->getModelCardDatabase(); modelCardDBase != nullptr)
+	if (auto modelCardDBase = connector()->getModelCardDatabase(); modelCardDBase != nullptr)
 		modelCardDBase->write(card);
 } //UpdateModel::run
@@ -5,25 +5,22 @@
 #include "Connector/Connector.h"
 #include "Connector/ConnectorResource.h"
 #include "Connector/Database/ModelCardDatabase.h"
-#include "Connector/Environment/ConnectorProject.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
 #include "Connector/Interface/Browser/Bridge/Send/Arg/SendViaBrowserArgs.h"
 #include "Connector/Record/Collection/ProjectCollection.h"
-#include "Connector/Record/Model/SenderModelCard.h"
-#include "Connector/Record/Model/Filter/SendFilter.h"
 #include "Speckle/Database/AccountDatabase.h"
 #include "Speckle/Database/Content/BIMRecord.h"
 #include "Speckle/Interface/Browser/Bridge/BrowserBridge.h"
 #include "Speckle/Record/Credentials/Account.h"
 #include "Speckle/Serialise/Detached/Storage/DetachedMemoryStore.h"
 #include "Speckle/Utility/Exception.h"
+
 #include "Speckle/Database/BIMElementDatabase.h"
 #include "Speckle/Environment/Project.h"
 #include "Speckle/Record/Element/Element.h"
-
 using namespace speckle::record::element;
+
 using namespace active::serialise;
-using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace connector::record;
 using namespace speckle::database;
@@ -44,25 +41,8 @@ Send::Send() : BridgeMethod{"Send", [&](const SendArgs& args) {
 	modelCardID: The ID of the model card identifying the objects to send
  --------------------------------------------------------------------*/
 void Send::run(const String& modelCardID) const {
-
-#ifdef ARCHICAD
-	// we currently rely on the ModelerAPI instead of the ModelAccessAPI
-	// we have to open a 3D window to get the Mesh data of the model elements
-	ACAPI_View_ShowAllIn3D();
-#endif
-
-		//Get the active project
-	auto project = connector()->getActiveProject().lock();
-	if (!project) {
-		getBridge()->sendEvent("setModelError",
-					std::make_unique<SendError>(connector()->getLocalString(errorString, noProjectOpenID), modelCardID));
-		return;
-	}
-	auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-	if (!connectorProject)
-		return;
 		//Find the specified model card
-	auto modelCardDatabase = connectorProject->getModelCardDatabase();
+	auto modelCardDatabase = connector()->getModelCardDatabase();
 	auto modelCard = modelCardDatabase->getCard(modelCardID);
 	if (!modelCard) {
 		getBridge()->sendEvent("setModelError",
@@ -77,13 +57,21 @@ void Send::run(const String& modelCardID) const {
 					std::make_unique<SendError>(connector()->getLocalString(errorString, accountNotFoundID), modelCardID));
 		return;
 	}
-		//Get the selected elements from the modelcard
-	auto elementDatabase = project->getElementDatabase();
-	ElementIDList selected{};
-	if (auto senderCard = dynamic_cast<SenderModelCard*>(modelCard.get())) {
-		selected = senderCard->getFilter().getElementIDs();
+		//Get the active project
+	auto project = connector()->getActiveProject().lock();
+	if (!project) {
+		getBridge()->sendEvent("setModelError",
+					std::make_unique<SendError>(connector()->getLocalString(errorString, noProjectOpenID), modelCardID));
+		return;
+	}
+		//Get the selected elements
+	auto elementDatabase = project->getElementDatabase();
+	auto selected = elementDatabase->getSelection();
+	if (selected.empty()) {
+		getBridge()->sendEvent("setModelError",
+					std::make_unique<SendError>(connector()->getLocalString(errorString, noSelectedModelItemsID), modelCardID));
+		return;
 	}
-
 		//Build a collection from the selected elements
 	auto collection = std::make_unique<ProjectCollection>(project);
 	for (const auto& link : selected) {
@@ -5,7 +5,6 @@
 #include "Connector/Connector.h"
 #include "Connector/ConnectorResource.h"
 #include "Connector/Database/ModelCardDatabase.h"
-#include "Connector/Environment/ConnectorProject.h"
 #include "Speckle/Event/Type/ElementEvent.h"
 #include "Speckle/Record/Element/Element.h"
 #include "Speckle/Database/BIMElementDatabase.h"
@@ -17,7 +16,6 @@
 #include "Connector/Record/Model/Filter/SendFilter.h"

 using namespace speckle::database;
-using namespace connector::environment;
 using namespace connector::interfac::browser::bridge;
 using namespace speckle::utility;
 using namespace speckle::event;
@@ -32,6 +30,22 @@ SendBridge::SendBridge() : BrowserBridge{"sendBinding"} {
 	addMethod<GetSendFilters>();
 	addMethod<GetSendSettings>();
 	addMethod<Send>();
+
+	// POC: do we have a better place to attach observer to elements?
+#ifdef ARCHICAD
+	auto project = connector()->getActiveProject().lock();
+	if (!project) {
+		// TODO: is this OK? should this throw?
+		return;
+	}
+
+	auto elementDatabase = project->getElementDatabase();
+	auto elements = elementDatabase->getElements();
+	ElementIDList elementIds;
+	for (const auto& id : elementIds) {
+		ACAPI_Element_AttachObserver(id);
+	}
+#endif
 } //SendBridge::SendBridge


@@ -50,13 +64,9 @@ bool SendBridge::handle(const ElementEvent& event) {
 			m_changedElements.clear();
 			break;
 		case end: {
-			auto project = connector()->getActiveProject().lock();
-			auto connectorProject = dynamic_cast<ConnectorProject*>(project.get());
-			if (!connectorProject)
-				return false;
-			auto modelCardDatabase = connectorProject->getModelCardDatabase();
+			auto modelCardDatabase = connector()->getModelCardDatabase();
 			auto modelCards = modelCardDatabase->getCards();
-				// POC: this is probably not efficient, should test, review and refactor it
+			// POC: this is probably not efficient, should test, review and refactor it
 			RecordIDList expiredModelCardIds;
 			for (const auto& modelCard : modelCards) {
 				if (auto senderCard = dynamic_cast<SenderModelCard*>(modelCard.get())) {
@@ -83,5 +93,5 @@ bool SendBridge::handle(const ElementEvent& event) {
 		default:
 		  break;
 	}
-	return false;
+	return true;
 } //SendBridge::handle
@@ -17,8 +17,6 @@
 #include "Speckle/Event/Type/MenuEvent.h"
 #include "Speckle/Interface/Browser/JSPortal.h"

-#include "Speckle/Event/Type/ProjectEvent.h"
-
 #include <ACAPinc.h>
 #include <DGModule.hpp>
 #include <DGBrowser.hpp>
@@ -110,9 +108,7 @@ ConnectorPalette::ConnectorPalette() {
 	return: The subscription list (an empty list will put the subscriber into a suspended state)
  --------------------------------------------------------------------*/
 ConnectorPalette::Subscription ConnectorPalette::subscription() const {
-	auto result = ProjectSubscriber::subscription();
-	result.insert(toggleConnectorPaletteID);
-	return result;
+	return { {toggleConnectorPaletteID} };
 } //ConnectorPalette::subscription


@@ -134,49 +130,16 @@ bool ConnectorPalette::start() {
 	return: True if the event should be closed
  --------------------------------------------------------------------*/
 bool ConnectorPalette::receive(const active::event::Event& event) {
-	if (event == toggleConnectorPaletteID) {
-		if (BrowserPalette::HasInstance() && BrowserPalette::GetInstance().IsVisible()) {
-			BrowserPalette::GetInstance().Hide();
-		}
-		else {
-			if (!BrowserPalette::HasInstance())
-				BrowserPalette::CreateInstance();
-			BrowserPalette::GetInstance().Show();
-		}
-		return true;
+	if (BrowserPalette::HasInstance() && BrowserPalette::GetInstance().IsVisible()) {
+		BrowserPalette::GetInstance().Hide ();
+	} else {
+		if (!BrowserPalette::HasInstance())
+			BrowserPalette::CreateInstance();
+		BrowserPalette::GetInstance().Show();
 	}
-
-	return ProjectSubscriber::receive(event);
-	
+	return true;
 } //ConnectorPalette::receive

-/*--------------------------------------------------------------------
-	Handle a project event
-
-	event: The project event
-
-	return: True if the event should be closed
- --------------------------------------------------------------------*/
-bool ConnectorPalette::handle(const speckle::event::ProjectEvent& event) {
-	using enum speckle::event::ProjectEvent::Type;
-	switch (event.getType()) {
-	case open: {
-		if (BrowserPalette::HasInstance() && !BrowserPalette::GetInstance().IsVisible()) {
-			BrowserPalette::GetInstance().Show();
-			BrowserPalette::GetInstance().EnableItems();
-		}
-	} break;
-	case close: {
-		if (BrowserPalette::HasInstance() && BrowserPalette::GetInstance().IsVisible()) {
-			BrowserPalette::GetInstance().Hide();
-		}
-	} break;
-	default:
-		break;
-	}
-	return false;
-} //ConnectorPalette::handle
-

 	//NB: Following is placeholder from GS example code - will be refactored to better suit our purposes

@@ -265,8 +228,8 @@ void BrowserPalette::Hide() {

 void BrowserPalette::InitBrowserControl() {
 #ifdef TESTING_MODE
+	browser->LoadURL("https://deploy-preview-3180--boisterous-douhua-e3cefb.netlify.app/");
 	//browser->LoadURL("https://boisterous-douhua-e3cefb.netlify.app/test");
-	browser->LoadURL("https://boisterous-douhua-e3cefb.netlify.app");
 #else
 	browser->LoadURL("https://boisterous-douhua-e3cefb.netlify.app/");
 #endif
@@ -319,10 +282,18 @@ GSErrCode __ACENV_CALL	BrowserPalette::PaletteControlCallBack(Int32, API_Palette
 			break;

 		case APIPalMsg_HidePalette_End:
-			if (HasInstance() && !GetInstance().IsVisible())
-			{
+			if(HasInstance() && !GetInstance().IsVisible())
 				GetInstance().Show();
-			}
+			break;
+
+		case APIPalMsg_DisableItems_Begin:
+			if(HasInstance() && GetInstance().IsVisible())
+				GetInstance().DisableItems();
+			break;
+
+		case APIPalMsg_DisableItems_End:
+			if(HasInstance() && GetInstance().IsVisible())
+				GetInstance().EnableItems();
 			break;

 		case APIPalMsg_IsPaletteVisible:
@@ -2,11 +2,10 @@
 #define CONNECTOR_CONNECTOR_PALETTE

 #include "Active/Event/Subscriber.h"
-#include "Speckle/Event/Subscriber/ProjectSubscriber.h"

 namespace connector {
 	
-	class ConnectorPalette : public speckle::event::ProjectSubscriber {
+	class ConnectorPalette : public active::event::Subscriber {
 	public:
 		/*!
 		 Default constructor
@@ -33,13 +32,6 @@ namespace connector {
 			@return True if the event should be closed
 		*/
 		bool receive(const active::event::Event& event) override;
-	protected:
-		/*!
-		 Handle the project events
-		 @param event The project event
-		 @return True if the event should be closed
-		 */
-		bool handle(const speckle::event::ProjectEvent& event) override;
 	};
 	
 }
@@ -115,12 +115,12 @@ bool ProjectCollection::addElement(const speckle::record::element::Element& elem
 
 	return: True if the material proxy was added (false typically means the record already exists)
  --------------------------------------------------------------------*/
-bool ProjectCollection::addFinishProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) {
+bool ProjectCollection::addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) {
 	auto iter = m_finishProxies.find(materialIndex);
 	if (iter == m_finishProxies.end())
 		iter = m_finishProxies.insert({materialIndex, {}}).first;
 	return iter->second.insert(objectID).second;
-} //ProjectCollection::addFinishProxy
+} //ProjectCollection::addMaterialProxy


 #ifdef ARCHICAD
@@ -132,12 +132,12 @@ bool ProjectCollection::addFinishProxy(const speckle::database::BIMIndex& materi
 
 	return: True if the material proxy was added (false typically means the record already exists)
  --------------------------------------------------------------------*/
-bool ProjectCollection::addFinishProxy(const Finish& finish, const speckle::database::BIMRecordID& objectID) {
+bool ProjectCollection::addMaterialProxy(const Finish& finish, const speckle::database::BIMRecordID& objectID) {
 	auto iter = m_finishes->find(finish.getBIMID());
 	if (iter == m_finishes->end())
 		iter = m_finishes->insert({finish.getBIMID(), finish}).first;
-	return addFinishProxy(speckle::database::BIMIndex{finish.getBIMID()}, objectID);
-} //ProjectCollection::addFinishProxy
+	return addMaterialProxy(speckle::database::BIMIndex{finish.getBIMID()}, objectID);
+} //ProjectCollection::addMaterialProxy
 #endif


@@ -69,14 +69,14 @@ namespace connector::record {
 		 @param objectID The object the material is applied to
 		 @return True if the material proxy was added (false typically means the record already exists)
 		 */
-		bool addFinishProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) override;
+		bool addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) override;
 		/*!
 		 Add a ModelerAPI material to the collection (NB: These are not persistent so need to be captured by this method)
 		 @param finish A finish
 		 @param objectID The object the material is applied to
 		 @return True if the material proxy was added (false typically means the record already exists)
 		 */
-		bool addFinishProxy(const speckle::record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) override;
+		bool addMaterialProxy(const speckle::record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) override;
 		
 		// MARK: - Serialisation
 		
@@ -11,6 +11,5 @@
 #include "Speckle.grc.rc2"

 #include "ConnectorFix.grc.rc2"
-#include "ConnectorImagesFix.grc.rc2"

 1	ICON	LOADONCALL MOVEABLE IMPURE  ACAP.ico
@@ -1,10 +0,0 @@
-
-#ifdef macintosh
-'GICN' 32500  "Speckle menu icon" {
-	"32500Mac"
-}
-#else
-'GICN' 32500  "Speckle menu icon" {
-	"32500Win"
-}
-#endif
@@ -1,5 +0,0 @@
-<svg width="52" height="52" viewBox="0 0 52 52" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M9 10L2 4V44L9 50V10Z" stroke="black" stroke-width="3" stroke-linejoin="round"/>
-<path d="M43 2L2 4L9 10L50 8L43 2Z" stroke="black" stroke-width="3" stroke-linejoin="round"/>
-<path d="M50 8L9 10V50L50 48V8Z" stroke="black" stroke-width="3" stroke-linejoin="round"/>
-</svg>
@@ -1,5 +0,0 @@
-<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M7 8L0 2V42L7 48V8Z" fill="#313BCF"/>
-<path d="M41 0L0 2L7 8L48 6L41 0Z" fill="#7BBCFF"/>
-<path d="M48 6L7 8V48L48 46V6Z" fill="#047EFB"/>
-</svg>
@@ -1,5 +1,5 @@
 'STR#' 32500  "Connector Menu" {
-	/*[ 1]*/	"Speckle Connector^E3^EL^ES^ED^EE^EI^EW^ET^32500"
+	/*[ 1]*/	"Speckle Connector^E3^EL^ES^ED^EE^EI^EW^ET^"
 }


@@ -33,9 +33,8 @@ namespace speckle::database {
 	};

 		///Element database storage declaration
-	class BIMElementDatabase::Store : public Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID,
-			BIMRecordID, BIMRecordID, ElementStorage::TableType> {
-		using base = Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID, ElementStorage::TableType>;
+	class BIMElementDatabase::Store : public Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID> {
+		using base = Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID>;
 		using base::base;
 	};
 	
@@ -76,48 +75,6 @@ BIMElementDatabase::BIMElementDatabase() {
 BIMElementDatabase::~BIMElementDatabase() {}


-/*--------------------------------------------------------------------
-	Get the available element tables
- 
-	targetType: An optional filtr for table type to retrieve, e.g. get all sections (nullopt = all table types)
- 
-	return: A list of available tables
-  --------------------------------------------------------------------*/
-BIMRecordIDList BIMElementDatabase::getTables(std::optional<TableType> targetType) const {
-	return m_engine->getTables(targetType);
-} //BIMElementDatabase::getTables
-
-
-/*--------------------------------------------------------------------
-	Get the default dbase table
- 
-	return: The default dbase table (nullopt if no table is available)
-  --------------------------------------------------------------------*/
-std::optional<BIMRecordID> BIMElementDatabase::getDefaultTable() const {
-	return m_engine->getDefaultTable();
-} //BIMElementDatabase::getDefaultTable
-
-
-/*--------------------------------------------------------------------
-	Set the default dbase table
- 
-	tableID: The new default dbase table
-  --------------------------------------------------------------------*/
-void BIMElementDatabase::setDefaultTable(const BIMRecordID& tableID) const {
-	m_engine->setDefaultTable(tableID);
-} //BIMElementDatabase::setDefaultTable
-
-
-/*--------------------------------------------------------------------
-	Bring the view of this database to the front (i.e. so the user sees it)
- 
-	tableID: The ID of the table to bring to the front
-  --------------------------------------------------------------------*/
-void BIMElementDatabase::bringViewToFront(BIMRecordID tableID) const {
-	m_engine->bringViewToFront(tableID);
-} //BIMElementDatabase::bringViewToFront
-
-
 /*--------------------------------------------------------------------
 	Get the current user element selection
 
@@ -144,27 +101,10 @@ void BIMElementDatabase::clearSelection() const {
 } //BIMElementDatabase::clearSelection


-/*--------------------------------------------------------------------
-	Find a filtered list of objects
- 
-	filter: The object filter (nullptr = find all objects)
-	tableID: Optional table ID (defaults to the first table)
-	documentID: Optional document ID (filter for this document only - nullopt = all objects)
- 
-	return: A list containing IDs of found elements (empty if none found)
-  --------------------------------------------------------------------*/
-BIMRecordIDList BIMElementDatabase::findElements(const Filter& filter, std::optional<BIMRecordID> tableID,
-														  std::optional<BIMRecordID> documentID) const {
-	return m_engine->findObjects(filter, tableID, documentID);
-} //BIMElementDatabase::findElements
-
-
 /*--------------------------------------------------------------------
 	Get a specified element
 
 	elementID: The ID of the target element
-	tableID: Optional table ID (defaults to the first table)
-	documentID: Optional document ID (filter for this document only - nullopt = all objects)
 
 	return: The requested element (nullptr on failure)
  --------------------------------------------------------------------*/
@@ -177,14 +117,10 @@ Element::Unique BIMElementDatabase::getElement(const BIMRecordID& elementID, std
 /*--------------------------------------------------------------------
 	Get all elements
 
-	tableID: Optional table ID (defaults to the first table)
-	documentID: Optional document ID (filter for this document only - nullopt = all objects)
- 
 	return: All the elements
  --------------------------------------------------------------------*/
-Vector<Element> BIMElementDatabase::getElements(std::optional<BIMRecordID> tableID,
-												std::optional<BIMRecordID> documentID) const {
-	return m_store->getObjects(tableID, documentID);
+Vector<Element> BIMElementDatabase::getElements() const {
+	return m_store->getObjects();
 } //BIMElementDatabase::getElements


@@ -2,7 +2,6 @@
 #define CONNECTOR_DATABASE_BIM_ELEMENT_DATABASE

 #include "Speckle/Database/Identity/BIMLink.h"
-#include "Speckle/Database/Storage/Element/ElementStorage.h"
 #include "Speckle/Record/Element/Element.h"
 #include "Speckle/Record/Element/Interface/Part.h"
 #include "Speckle/Utility/Guid.h"
@@ -20,7 +19,7 @@ namespace speckle::database {
 	/*!
 	 Database of model elements relating to a specific project
 	 */
-	class BIMElementDatabase : public ElementStorage {
+	class BIMElementDatabase {
 	public:

 		// MARK: - Constructors
@@ -37,27 +36,6 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
-		/*!
-		 Get the available element tables
-		 @param targetType An optional filtr for table type to retrieve, e.g. get all sections (nullopt = all table types)
-		 @return A set of available tables
-		 */
-		BIMRecordIDList getTables(std::optional<TableType> targetType) const;
-		/*!
-		 Get the default dbase table
-		 @return The default dbase table (nullopt if no table is available)
-		 */
-		std::optional<BIMRecordID> getDefaultTable() const;
-		/*!
-		 Set the default dbase table
-		 @param tableID The new default dbase table
-		 */
-		void setDefaultTable(const BIMRecordID& tableID) const;
-		/*!
-		 Bring the view of this database to the front (i.e. so the user sees it)
-		 @param tableID The ID of the table to bring to the front
-		 */
-		void bringViewToFront(BIMRecordID tableID) const;
 		/*!
 		 Get the current user element selection
 		 @return A list of selected element IDs
@@ -71,15 +49,6 @@ namespace speckle::database {
 		 Clear the element selection
 		 */
 		void clearSelection() const;
-		/*!
-		 Find a filtered list of objects
-		 @param filter The object filter (nullptr = find all objects)
-		 @param tableID Optional table ID (defaults to the first table)
-		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
-		 @return A list containing IDs of found elements (empty if none found)
-		 */
-		BIMRecordIDList findElements(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
-											  std::optional<BIMRecordID> documentID = std::nullopt) const;
 		/*!
 		 Get a specified element
 		 @param elementID The ID of the target element
@@ -97,12 +66,9 @@ namespace speckle::database {
 		std::unique_ptr<record::element::Element> getElement(const BIMLink& link) const { return getElement(link, link.tableID, link.docID); }
 		/*!
 		 Get all model elements
-		 @param tableID Optional table ID (defaults to the first table)
-		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
 		 @return All the elements
 		 */
-		active::container::Vector<record::element::Element> getElements(std::optional<BIMRecordID> tableID = std::nullopt,
-																		std::optional<BIMRecordID> documentID = std::nullopt) const;
+		active::container::Vector<record::element::Element> getElements() const;
 		/*!
 		 Get memo memo (supplementary) data for a specified element
 		 @param elementID The of the source element
@@ -62,7 +62,7 @@ namespace speckle::database {
 		 Get a link to the BIM record
 		 @return The BIM record link
 		 */
-		virtual BIMLink getBIMLink() const { return BIMLink{BIMLink::base{m_applicationID, m_applicationTableID}}; }
+		BIMLink getBIMLink() const { return BIMLink{ BIMLink::base	{m_applicationID, m_applicationTableID} }; }
 		/*!
 		 Get the record unit type
 		 @return The record unit type (nullopt if the record has no applicable unit type)
@@ -34,7 +34,6 @@ namespace speckle::database {
 		using Attribute = record::attribute::Attribute;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -52,15 +51,6 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
-		/*!
-		 Find a filtered list of objects
-		 @param filter The object filter (nullptr = find all objects)
-		 @param tableID Optional table ID (defaults to the first table)
-		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
-		 @return A list containing IDs of found elements (empty if none found)
-		 */
-		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
-									  std::optional<BIMRecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Get an object by ID
 		 @param objID The object ID
@@ -74,7 +64,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (defaults to the floor plan)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return The requested wrapped cargo (nullptr on failure)
+		 @return: The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -16,12 +16,6 @@
 #include "Speckle/Record/Element/Beam.h"
 #include "Speckle/Record/Element/BeamSegment.h"
 #include "Speckle/Record/Element/Memo.h"
-#include "Speckle/Record/Element/MeshElem.h"
-#include "Speckle/Record/Element/Morph.h"
-#include "Speckle/Record/Element/Roof.h"
-#include "Speckle/Record/Element/Shell.h"
-#include "Speckle/Record/Element/Slab.h"
-#include "Speckle/Record/Element/Wall.h"
 #include "Speckle/Utility/Guid.h"
 #include "Speckle/Utility/String.h"

@@ -41,24 +35,14 @@ using enum ArchicadDBaseCore::Status;

 namespace {
 	
-		//ID for the floor plan view
-	static const Guid primary2DViewID{String{"ddad27c0-c17b-4ad3-b76b-53d1e176d5ef"}};
-		//ID for the 3D view
-	static const Guid primary3DViewID{String{"ec368939-fb7d-4d8c-bc88-6d29806d9212"}};
-
 	/*!
 	 Get information about a specified Archicad table
 	 @param tableID The ID of the target table
 	 @return The requested table info (nullopt on failure)
 	 */
 	std::optional<API_DatabaseInfo> getTableInfo(const BIMRecordID& tableID) {
-		API_DatabaseInfo dbaseInfo{};
-		if (tableID == primary2DViewID)
-			dbaseInfo.typeID = APIWind_FloorPlanID;
-		else if (tableID == primary3DViewID)
-			dbaseInfo.typeID = APIWind_3DModelID;
-		else
-			dbaseInfo.databaseUnId.elemSetId = tableID;
+		API_DatabaseInfo dbaseInfo;
+		dbaseInfo.databaseUnId.elemSetId = tableID;
 		if (auto err = ACAPI_Window_GetDatabaseInfo(&dbaseInfo); err == NoError)
 			return dbaseInfo;
 		return std::nullopt;
@@ -72,7 +56,7 @@ namespace {
 	 */
 	bool setActiveTable(const BIMRecordID& tableID) {
 		if (!tableID)
-			return false;	//Null guid doesn't point to anything
+			return false;	//Null guid doens't point to anything
 		if (auto activeTable = ArchicadElementDBaseEngine::getActiveTable(); activeTable && *activeTable == tableID)
 			return true;
 		auto dbaseInfo = getTableInfo(tableID);
@@ -98,22 +82,6 @@ namespace {
 				return std::make_unique<Beam>(elementData, tableID);
 			case API_BeamSegmentID:
 				return std::make_unique<BeamSegment>(elementData, tableID);
-			case API_MeshID:
-				return std::make_unique<Mesh>(elementData, tableID);
-			case API_MorphID:
-				return std::make_unique<Morph>(elementData, tableID);
-			case API_RoofID:
-				return std::make_unique<Roof>(elementData, tableID);
-			case API_ShellID:
-				return std::make_unique<Shell>(elementData, tableID);
-			case API_SlabID:
-				return std::make_unique<Slab>(elementData, tableID);
-			case API_WallID:
-				return std::make_unique<Wall>(elementData, tableID);
-			case API_ObjectID:
-				// POC: change this case once we are ready to convert Grid Elements
-				if (elementData.header.type.variationID == APIVarId_GridElement)
-					return nullptr;
 			default:
 				return std::make_unique<GenericModelElement>(elementData, tableID);
 		}
@@ -128,34 +96,12 @@ namespace {
 std::optional<BIMRecordID> ArchicadElementDBaseEngine::getActiveTable() {
 	API_WindowInfo dbaseInfo;
 	active::utility::Memory::erase(dbaseInfo);
-	if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError) {
-		if (dbaseInfo.typeID == APIWind_FloorPlanID)
-			return primary2DViewID;
-		else if (dbaseInfo.typeID == APIWind_3DModelID)
-			return primary3DViewID;
+	if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError)
 		return dbaseInfo.databaseUnId.elemSetId;
-	}
 	return std::nullopt;
 } //ArchicadElementDBaseEngine::getActiveTable


-/*--------------------------------------------------------------------
-	Bring the view of this database to the front (i.e. so the user sees it)
- 
-	tableID: The ID of the table to bring to the front
-  --------------------------------------------------------------------*/
-void ArchicadElementDBaseEngine::bringViewToFront(BIMRecordID tableID) const {
-	auto dbaseInfo = getTableInfo(tableID);
-	if (!dbaseInfo)
-		return;
-	API_WindowInfo windowInfo{};
-	windowInfo.typeID = dbaseInfo->typeID;
-	if ((windowInfo.typeID != APIWind_FloorPlanID) && (windowInfo.typeID != APIWind_3DModelID))
-		windowInfo.databaseUnId = dbaseInfo->databaseUnId;
-	ACAPI_Window_ChangeWindow(&windowInfo);
-} //ArchicadElementDBaseEngine::bringViewToFront
-
-
 /*--------------------------------------------------------------------
 	Get the current user element selection
 
@@ -198,73 +144,6 @@ void ArchicadElementDBaseEngine::clearSelection() const {
 } //ArchicadElementDBaseEngine::clearSelection


-/*--------------------------------------------------------------------
-	Get the available dbase tables
- 
-	targetType: An optional filtr for table type/group to retrieve
- 
-	return: A list of available tables
-  --------------------------------------------------------------------*/
-ArchicadElementDBaseEngine::TableIDList ArchicadElementDBaseEngine::getTables(std::optional<TableType> targetType) const {
-	using enum ElementStorage::TableType;
-	TableIDList result;
-	if (!targetType || (targetType == primary2D))
-		result.insert(primary2DViewID);
-	if (!targetType || (targetType == primary3D))
-		result.insert(primary3DViewID);
-	return result;
-} //ArchicadElementDBaseEngine::getTables
-
-
-/*--------------------------------------------------------------------
-	Get the default dbase table
- 
-	return: The default dbase table (nullopt if no table is available)
-  --------------------------------------------------------------------*/
-std::optional<BIMRecordID> ArchicadElementDBaseEngine::getDefaultTable() const {
-	return ArchicadElementDBaseEngine::getActiveTable();
-} //ArchicadElementDBaseEngine::getDefaultTable
-
-
-/*--------------------------------------------------------------------
-	Set the default dbase table
- 
-	tableID: The new default dbase table
-  --------------------------------------------------------------------*/
-void ArchicadElementDBaseEngine::setDefaultTable(const BIMRecordID& tableID) const {
-	setActiveTable(tableID);
-} //ArchicadElementDBaseEngine::setDefaultTable
-
-
-/*--------------------------------------------------------------------
-	Find a filtered list of objects
- 
-	filter: The object filter (nullptr = find all objects)
-	tableID: Optional table ID (defaults to the first table)
-	documentID: Optional document ID (filter for this document only - nullopt = all objects)
- 
-	return: A list containing IDs of found elements (empty if none found)
-  --------------------------------------------------------------------*/
-BIMRecordIDList ArchicadElementDBaseEngine::findObjects(const Filter& filter, std::optional<BIMRecordID> tableID,
-																		 std::optional<BIMRecordID> documentID) const {
-		//Switch to the target table (when specified). Otherwise the currently active table will be used
-	if (tableID)
-		setActiveTable(*tableID);
-		//First check for no filter (in which case we return all objects)
-	if (filter == nullptr) {
-		GS::Array<API_Guid> found;
-		if ((ACAPI_Element_GetElemList({}, &found) != NoError) || found.IsEmpty())
-			return {};
-		BIMRecordIDList result;
-		for (const auto& item : found)
-			result.insert(item);
-		return result;
-	}
-		//Implement other filtering as required - ideally identify characteristics supported by API, e.g. filter by type/renovation etc
-	return {};
-} //ArchicadElementDBaseEngine::findObjects
-
-
 /*--------------------------------------------------------------------
 	Get an object by index
 
@@ -332,19 +211,7 @@ active::container::Vector<Element> ArchicadElementDBaseEngine::getObjects(std::o
 																					  std::optional<BIMRecordID> documentID) const {
 	if (tableID)
 		setActiveTable(*tableID);
-	else {			
-			//Use the active table if none is specified
-		tableID = getActiveTable();
-		if (!tableID)
-			return {};
-	}
-		//Retrieve the element objects to build the result
-	active::container::Vector<Element> result;
-	auto objectIDs = findObjects();
-	for (const auto& ID : objectIDs)
-		if (auto element = getObject(ID, tableID); element)
-			result.emplace_back(std::move(element));
-	return result;
+	return {}; //TODO: Implement
 } //ArchicadElementDBaseEngine::getObjects


@@ -4,7 +4,6 @@
 #include "Active/Database/Storage/DBaseEngine.h"
 #include "Active/Serialise/UnboxedTransport.h"
 #include "Speckle/Database/Storage/ArchicadDBase/ArchicadDBaseCore.h"
-#include "Speckle/Database/Storage/Element/ElementStorage.h"
 #include "Speckle/Database/Identity/BIMLink.h"
 #include "Speckle/Record/Element/Element.h"
 #include "Speckle/Utility/Guid.h"
@@ -18,17 +17,16 @@ namespace speckle::database {
 	/*!
 	 A database engine to read/write elements in an Archicad project database (local file or cloud-based)
 	 */
-	class ArchicadElementDBaseEngine : public ArchicadDBaseCore, public ElementStorage,
-			public active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID, ElementStorage::TableType>  {
+	class ArchicadElementDBaseEngine : public ArchicadDBaseCore,
+			public active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID>  {
 	public:
 		
 		// MARK: - Types
 		
 		using base = active::database::DBaseEngine<record::element::Element, BIMRecordID, BIMRecordID, BIMRecordID>;
 		using Element = record::element::Element;
-		using Filter = ElementStorage::Filter;
+		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constants
 		
@@ -55,11 +53,6 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
-		/*!
-		 Bring the view of this database to the front (i.e. so the user sees it)
-		 @param tableID The ID of the table to bring to the front
-		 */
-		void bringViewToFront(BIMRecordID tableID) const;
 		/*!
 		 Get the current user element selection
 		 @return A list of selected element IDs
@@ -73,31 +66,6 @@ namespace speckle::database {
 		 Clear the element selection
 		 */
 		void clearSelection() const;
-		/*!
-		 Get the available dbase tables
-		 @param targetType An optional filtr for table type/group to retrieve
-		 @return A list of available tables
-		 */
-		TableIDList getTables(std::optional<TableType> targetType) const override;
-		/*!
-		 Get the default dbase table
-		 @return The default dbase table (nullopt if no table is available)
-		 */
-		std::optional<BIMRecordID> getDefaultTable() const;
-		/*!
-		 Set the default dbase table
-		 @param tableID The new default dbase table
-		 */
-		void setDefaultTable(const BIMRecordID& tableID) const;
-		/*!
-		 Find a filtered list of objects
-		 @param filter The object filter (nullptr = find all objects)
-		 @param tableID Optional table ID (defaults to the first table)
-		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
-		 @return A list containing IDs of found elements (empty if none found)
-		 */
-		virtual BIMRecordIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
-									  std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
 		 Get an object by index
 		 @param objID The object ID
@@ -111,7 +79,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (defaults to the floor plan)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return The requested wrapped cargo (nullptr on failure)
+		 @return: The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -29,7 +29,6 @@ namespace speckle::database {
 		using Group = record::property::Group;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -47,15 +46,6 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
-		/*!
-		 Find a filtered list of objects
-		 @param filter The object filter (nullptr = find all objects)
-		 @param tableID Optional table ID (defaults to the first table)
-		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
-		 @return A list containing IDs of found elements (empty if none found)
-		 */
-		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
-									  std::optional<BIMRecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Get an object by ID
 		 @param objID The object ID
@@ -69,7 +59,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (default selected based on record type)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return The requested wrapped cargo (nullptr on failure)
+		 @return: The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -30,7 +30,6 @@ namespace speckle::database {
 		using Template = record::property::Template;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		
 		// MARK: - Constructors
 		
@@ -48,15 +47,6 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
-		/*!
-		 Find a filtered list of objects
-		 @param filter The object filter (nullptr = find all objects)
-		 @param tableID Optional table ID (defaults to the first table)
-		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
-		 @return A list containing IDs of found elements (empty if none found)
-		 */
-		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<BIMRecordID> tableID = std::nullopt,
-									  std::optional<BIMRecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Find all property templates linked to specified classifications
 		 @param classifications The classifications
@@ -76,7 +66,7 @@ namespace speckle::database {
 		 @param objID The object ID
 		 @param tableID Optional table ID (default selected based on record type)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return The requested wrapped cargo (nullptr on failure)
+		 @return: The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
 		/*!
@@ -46,7 +46,6 @@ namespace speckle::database {
 		using base = active::database::DBaseEngine<Obj, ObjID, RecordID, RecordID>;
 		using Filter = base::Filter;
 		using Outline = base::Outline;
-		using ObjIDList = base::ObjIDList;
 		using Cache = active::database::RecordCache<Obj, ObjWrapper, ObjID, RecordID, RecordID>;
 		
 		// MARK: - Constructors
@@ -60,15 +59,6 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
-		/*!
-		 Find a filtered list of objects
-		 @param filter The object filter (nullptr = find all objects)
-		 @param tableID Optional table ID (defaults to the first table)
-		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
-		 @return A list containing IDs of found elements (empty if none found)
-		 */
-		virtual ObjIDList findObjects(const Filter& filter = nullptr, std::optional<RecordID> tableID = std::nullopt,
-									  std::optional<RecordID> documentID = std::nullopt) const override { return {}; }	//Implement when required
 		/*!
 		 Get an object by index
 		 @param ID The object ID
@@ -82,7 +72,7 @@ namespace speckle::database {
 		 @param ID The object ID
 		 @param tableID Optional table ID (defaults to the first table)
 		 @param documentID Optional document ID (when the object is bound to a specific document)
-		 @return The requested wrapped cargo (nullptr on failure)
+		 @return: The requested wrapped cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getObjectCargo(const ObjID& objID, std::optional<RecordID> tableID = std::nullopt, std::optional<RecordID> documentID = std::nullopt) const override;
 		/*!
@@ -181,10 +171,8 @@ namespace speckle::database {
 			//Read the data stored in the document
 		auto storedData = readStore();
 		m_cache = std::make_unique<Cache>();
-		if (!storedData) {
-			m_cache->setID(speckle::utility::Guid{true}.operator speckle::utility::String()); //Needs an ID - substitute for the Speckle 'document ID'
+		if (!storedData)
 			return m_cache.get();	//Return an empty container if there's no data
-		}
 			//Import the document data into the record cache
 		if constexpr (std::is_same_v<ObjWrapper, Obj>)
 			Transport().receive(std::forward<active::serialise::Cargo&&>(*m_cache), active::serialise::Identity{}, storedData);
@@ -1,29 +0,0 @@
-#ifndef SPECKLE_DATABASE_ELEMENT_STORAGE
-#define SPECKLE_DATABASE_ELEMENT_STORAGE
-
-#include "Speckle/Record/Element/Element.h"
-
-namespace speckle::database {
-	
-	/*!
-	 Fundamental concepts for element storage
-	 */
-	class ElementStorage {
-	public:
-		
-		// MARK: - Types
-		
-			///Element storage table types
-		enum class TableType {
-			primary2D,
-			primary3D,
-			section,
-			elevation,
-		};
-			///Element filter
-		using Filter = std::function<bool(const record::element::Element&)>;
-	};
-	
-}
-
-#endif	//SPECKLE_DATABASE_ELEMENT_STORAGE
@@ -2,7 +2,6 @@

 #include "Speckle/Environment/Project.h"
 #include "Speckle/Event/Type/ProjectEvent.h"
-#include "Speckle/Event/Subscriber/ProjectSubscriber.h"

 #include <limits>

@@ -19,14 +18,6 @@ namespace {
 		//An object representing the active addon
 	Addon* m_addonInstance = nullptr;

-		///An instance of this class is used to force project notifications to be issued from the moment the add-on is launched
-	class DummyProjectSubscriber : public ProjectSubscriber {
-	public:
-		bool start() override { return ProjectSubscriber::start(); }
-		bool handle(const ProjectEvent& event) override { return false; }
-	};
-
-	
 }

 /*--------------------------------------------------------------------
@@ -130,8 +121,6 @@ bool Addon::attach() {
 	return: True if the participant is able to continue
  --------------------------------------------------------------------*/
 bool Addon::start() {
-		//Force project notifications to be published
-	DummyProjectSubscriber().start();
 		//Add add-on functionality as required
 	return App::start();
 } //Addon::start
@@ -40,7 +40,7 @@ namespace speckle::environment {
 		 Get the active project
 		 @return The active project (nullptr = no open project)
 		 */
-		virtual std::weak_ptr<Project> getActiveProject() const;
+		std::weak_ptr<Project> getActiveProject() const;
 		/*!
 		 Get the session index
 		 @return The session index (non-recursive entries into the add-on)
@@ -48,7 +48,7 @@ namespace speckle::environment {
 		/*!
 		 Destructor
 		 */
-		virtual ~Project();
+		~Project();
 		
 		// MARK: - Functions (const)
 		
@@ -31,8 +31,7 @@ namespace {
 		switch (elemType->notifID)
 		{
 			case APINotifyElement_New: {
-				// POC: Put this back once we decide to use Object Tracking
-				// ACAPI_Element_AttachObserver(elemType->elemHead.guid);
+				ACAPI_Element_AttachObserver(elemType->elemHead.guid);
 				addon()->publishExternal(ElementEvent{newElem, ElementID{elemType->elemHead.guid}});
 			} break;
 			case APINotifyElement_Change: {
@@ -1,7 +1,6 @@
 #include "Speckle/Primitive/Mesh/Mesh.h"

 #include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Item/Wrapper/FastDoubleWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
 #include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Active/Serialise/Inventory/Identity.h"
@@ -20,6 +19,10 @@ namespace {
 		vertexID,
 		faceID,
 		colorID,
+		pointID,
+		closedID,
+		lengthID,
+		areaID,
 	};

 		///Serialisation field IDs
@@ -27,6 +30,10 @@ namespace {
 		Identity{"vertices"},
 		Identity{"faces"},
 		Identity{"colors"},
+		Identity{"value"},
+		Identity{"closed"},
+		Identity{"length"},
+		Identity{"area"},
 	};

 }
@@ -54,6 +61,13 @@ void Mesh::appendFace(const std::vector<double>& vertices) {
 	return: True if the package has added items to the inventory
  --------------------------------------------------------------------*/
 bool Mesh::fillInventory(Inventory& inventory) const {
+	if (isPolyline)
+		return fillInventoryPolyline(inventory);
+	else
+		return fillInventoryMesh(inventory);
+} //Mesh::fillInventory
+
+bool Mesh::fillInventoryMesh(Inventory& inventory) const {
 	using enum Entry::Type;
 	inventory.merge(Inventory{
 		{
@@ -61,9 +75,22 @@ bool Mesh::fillInventory(Inventory& inventory) const {
 			{ fieldID[faceID], faceID, element },
 			{ fieldID[colorID], colorID, element },
 		},
-	}.withType(&typeid(Mesh)));
+		}.withType(&typeid(Mesh)));
 	return base::fillInventory(inventory);
-} //Mesh::fillInventory
+}
+
+bool Mesh::fillInventoryPolyline(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[pointID], pointID, element },
+			{ fieldID[closedID], closedID, element },
+			{ fieldID[lengthID], lengthID, element },
+			{ fieldID[areaID], areaID, element },
+		},
+		}.withType(&typeid(Mesh)));
+	return base::fillInventory(inventory);
+}


 /*--------------------------------------------------------------------
@@ -74,20 +101,46 @@ bool Mesh::fillInventory(Inventory& inventory) const {
 	return: The requested cargo (nullptr on failure)
  --------------------------------------------------------------------*/
 Cargo::Unique Mesh::getCargo(const Inventory::Item& item) const {
+	if (isPolyline)
+		return getCargoPolyline(item);
+	else
+		return getCargoMesh(item);
+	
+} //Mesh::getCargo
+
+Cargo::Unique Mesh::getCargoMesh(const Inventory::Item& item) const {
 	if (item.ownerType != &typeid(Mesh))
 		return base::getCargo(item);
 	using namespace active::serialise;
 	switch (item.index) {
 	case vertexID:
-			return std::make_unique<ContainerWrap<std::vector<double>, FastDoubleWrap>>(m_vertices);
-		case faceID:
-			return std::make_unique<ContainerWrap<std::vector<int>>>(m_faces);
-		case colorID:
-			return std::make_unique<ContainerWrap<std::vector<int>>>(m_colors);
-		default:
-			return nullptr;	//Requested an unknown index
+		return std::make_unique<ContainerWrap<std::vector<double>>>(m_vertices);
+	case faceID:
+		return std::make_unique<ContainerWrap<std::vector<int>>>(m_faces);
+	case colorID:
+		return std::make_unique<ContainerWrap<std::vector<int>>>(m_colors);
+	default:
+		return nullptr;	//Requested an unknown index
 	}
-} //Mesh::getCargo
+}
+
+Cargo::Unique Mesh::getCargoPolyline(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(Mesh))
+		return base::getCargo(item);
+	using namespace active::serialise;
+	switch (item.index) {
+	case pointID:
+		return std::make_unique<ContainerWrap<std::vector<double>>>(m_points);
+	case closedID:
+		return std::make_unique<ValueWrap<bool>>(isClosed);
+	case lengthID:
+		return std::make_unique<ValueWrap<double>>(length);
+	case areaID:
+		return std::make_unique<ValueWrap<double>>(area);
+	default:
+		return nullptr;	//Requested an unknown index
+	}
+}


 /*--------------------------------------------------------------------
@@ -99,6 +152,6 @@ void Mesh::useManagement(Management* management) const {
 		//NB: This object only exists to populate the finish collection - it doesn't carry any serialisable content
 	if (management != nullptr) {
 		if (auto collector = management->get<FinishCollector>(); collector != nullptr)
-			collector->addFinishProxy(m_finish, getBIMID());
+			collector->addMaterialProxy(m_finish, getBIMID());
 	}
 } //Mesh::useManagement
@@ -43,6 +43,10 @@ namespace speckle::primitive {
 		Mesh(std::vector<double>&& vertices, std::vector<int>&& faces, std::vector<int>&& colors, const record::attribute::Finish& finish,
 				active::measure::LengthType unit = active::measure::LengthType::metre) :
 				base{utility::Guid{true}, utility::Guid{}, unit}, m_vertices{std::move(vertices)}, m_faces{std::move(faces)}, m_colors{std::move(colors)}, m_finish{finish} {}
+
+		Mesh(std::vector<double>&& points, const record::attribute::Finish& finish,
+			active::measure::LengthType unit = active::measure::LengthType::metre) :
+			base{ utility::Guid{true}, utility::Guid{}, unit }, m_points{ std::move(points) }, m_finish{ finish } {}
 		
 		// MARK: - Functions (const)
 		
@@ -50,7 +54,13 @@ namespace speckle::primitive {
 		 Get the speckle type identifier
 		 @return The speckle type (relevant objects should override as required)
 		 */
-		speckle::utility::String getSpeckleType() const override { return "Objects.Geometry.Mesh"; }
+		speckle::utility::String getSpeckleType() const override 
+		{ 
+			if (isPolyline)
+				return "Objects.Geometry.Polyline";
+			else
+				return "Objects.Geometry.Mesh";
+		}

 		/*!
 		 Append a single face to the Mesh given by the vertices
@@ -66,23 +76,35 @@ namespace speckle::primitive {
 		 @return True if the package has added items to the inventory
 		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const override;
+		bool fillInventoryMesh(active::serialise::Inventory& inventory) const;
+		bool fillInventoryPolyline(active::serialise::Inventory& inventory) const;
 		/*!
 		 Get the specified cargo
 		 @param item The inventory item to retrieve
 		 @return The requested cargo (nullptr on failure)
 		 */
 		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		active::serialise::Cargo::Unique getCargoMesh(const active::serialise::Inventory::Item& item) const;
+		active::serialise::Cargo::Unique getCargoPolyline(const active::serialise::Inventory::Item& item) const;
 		/*!
 		 Use a manager in (de)serialisation processes
 		 @param management The management to use
 		 */
 		void useManagement(active::serialise::Management* management) const override;
+
+		void setToPolyline() { isPolyline = true; }
 		
 	private:
 		std::vector<double> m_vertices;
+		std::vector<double> m_points;
 		std::vector<int> m_faces;
 		std::vector<int> m_colors;
 		record::attribute::Finish m_finish;
+
+		bool isPolyline = false;
+		bool isClosed = false;
+		double length = 2.0;
+		double area = 0.0;
 	};
 	
 }
@@ -1,196 +0,0 @@
-#include "Speckle/Record/Attribute/Material.h"
-
-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Active/Serialise/Management/Management.h"
-#include "Active/Serialise/CargoHold.h"
-#include "Active/Utility/BufferOut.h"
-#include "Speckle/Serialise/Collection/FinishCollector.h"
-#include "Speckle/Serialise/Types/ArchicadRGB.h"
-#include "Speckle/Utility/Guid.h"
-
-using namespace active::serialise;
-using namespace speckle::database;
-using namespace speckle::record::attribute;
-using namespace speckle::serialise;
-using namespace speckle::utility;
-
-#include <array>
-#include <memory>
-
-namespace speckle::record::attribute {
-	
-		///Internal representation of a rendered finish on a 3D body, i.e. the surface colour/texture etc.
-	class Material::Data {
-	public:
-#ifdef ARCHICAD
-		/*!
-		 Constructor from Archicad material
-		 @param attr An Archicad attribute
-		 */
-		Data(const API_Attribute& attr) : root{attr.buildingMaterial} {
-		}
-		
-			///Archicad representation of a building material
-		API_BuildingMaterialType root;
-#endif
-	};
-	
-}
-
-namespace {
-	
-		///Serialisation fields
-	enum FieldIndex {
-		thermConductID,
-			//TODO: Add other fields as required
-	};
-
-		///Serialisation field IDs
-	static std::array fieldID = {
-		Identity{"thermalConductivity"},
-			//TODO: Add other fields as required
-	};
-
-}
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Material::Material() {
-} //Material::Material
-
-
-/*--------------------------------------------------------------------
-	Constructor
- 
-	ID: The attribute ID
-  --------------------------------------------------------------------*/
-Material::Material(const database::BIMRecordID& ID) : base{ID, Material::table} {
-} //Material::Material
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Constructor
- 
-	attrData: Archicad attribute data
-	tableID: The ID of the parent table
-  --------------------------------------------------------------------*/
-Material::Material(const API_Attribute& attrData, const BIMRecordID& tableID) : base{attrData.header.guid, Material::table} {
-	m_data = std::make_unique<Data>(attrData);
-	setUnit(std::nullopt);	//Finishes have no unit
-}
-#endif
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
- 
- 	source: The object to copy
-  --------------------------------------------------------------------*/
-Material::Material(const Material& source) : base{source} {
-	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-} //Material::Material
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-Material::~Material() {}
-
-
-/*--------------------------------------------------------------------
-	Assignment operator
- 
-	source: The object to assign
- 
-	return: A reference to this
-  --------------------------------------------------------------------*/
-Material& Material::operator=(const Material& source) {
-	if (this != &source) {
-		base::operator=(source);
-		m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-	}
-	return *this;
-} //Material::operator=
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Get the (immutable) API attribute header data
- 
-	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-const API_Attr_Head& Material::getHead() const {
-	confirmData();
-	return m_data->root.head;
-} //Material::getHead
-
-
-/*--------------------------------------------------------------------
-	Get the (mutable) API attribute header data
- 
-	return: The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-API_Attr_Head& Material::getHead() {
-	confirmData();
-	return m_data->root.head;
-} //Material::getHead
-#endif
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
- 
-	inventory: The inventory to receive the package items
- 
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool Material::fillInventory(Inventory& inventory) const {
-	using enum Entry::Type;
-	inventory.merge(Inventory{
-		{
-			{ fieldID[thermConductID], thermConductID, element },
-		},
-	}.withType(&typeid(Material)));
-	return base::fillInventory(inventory);
-} //Material::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
- 
-	item: The inventory item to retrieve
- 
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique Material::getCargo(const Inventory::Item& item) const {
-	if (item.ownerType != &typeid(Material))
-		return base::getCargo(item);
-	confirmData();
-	using namespace active::serialise;
-	switch (item.index) {
-		case thermConductID:
-			return std::make_unique<DoubleWrap>(m_data->root.thermalConductivity);
-		default:
-			return nullptr;	//Requested an unknown index
-	}
-} //Material::getCargo
-
-
-/*--------------------------------------------------------------------
-	Set to the default package content
-  --------------------------------------------------------------------*/
-void Material::setDefault() {
-	m_data->root = {};
-} //Material::setDefault
-
-
-/*--------------------------------------------------------------------
-	Confirm the internal data, either loading from the BIM application or setting a default
-  --------------------------------------------------------------------*/
-void Material::confirmData() const {
-	if (m_data)
-		return;
-	m_data = std::make_unique<Data>(getData());
-} //Material::confirmData
@@ -1,143 +0,0 @@
-#ifndef SPECKLE_RECORD_ATTRIBUTE_MATERIAL
-#define SPECKLE_RECORD_ATTRIBUTE_MATERIAL
-
-#include "Speckle/Record/Attribute/Attribute.h"
-
-#ifdef ARCHICAD
-namespace ModelerAPI {
-	class Material;
-}
-#endif
-
-namespace speckle::record::attribute {
-	
-	/*!
-	 Class to represent the construction material of a building element, e.g. concrete, timber, glass, stone etc
-	 
-	 Note the difference with a Finish (which is only applied to the surface).
-	 In Archicad this attribute is represented by `API_BuildingMaterialType`
-	 */
-	class Material : public Attribute {
-	public:
-
-		// MARK: - Types
-		
-		using base = Attribute;
-			///Unique pointer
-		using Unique = std::unique_ptr<Material>;
-			///Shared pointer
-		using Shared = std::shared_ptr<Material>;
-			///Optional
-		using Option = std::optional<Material>;
-		
-		// MARK: - Constants
-		
-#ifdef ARCHICAD
-			///The finishes table identifier
-		static constexpr active::utility::Guid table{active::utility::Guid::fromInt(API_BuildingMaterialID)};
-#endif
-
-		// MARK: - Constructors
-		
-		using base::base;
-		
-		/*!
-		 Default constructor
-		 */
-		Material();
-		/*!
-		 Constructor
-		 @param ID The attribute ID
-		 */
-		Material(const database::BIMRecordID& ID);
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param attrData Archicad attribute data
-		 @param tableID The ID of the parent table
-		 */
-		Material(const API_Attribute& attrData, const database::BIMRecordID& tableID);
-#endif
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Material(const Material& source);
-		/*!
-		 Destructor
-		 */
-		~Material();
-
-		/*!
-		 Object cloning
-		 @return A clone of this object
-		 */
-		Material* clonePtr() const override { return new Material{*this}; }
-		
-		// MARK: - Operators
-		
-		/*!
-		 Assignment operator
-		 @param source The object to assign
-		 @return A reference to this
-		 */
-		Material& operator=(const Material& source);
-
-		// MARK: - Functions (const)
-
-		/*!
-		 Get the speckle type identifier
-		 @return The speckle type (relevant objects should override as required)
-		 */
-		speckle::utility::String getSpeckleType() const override { return "Objects.Other.Material"; }
-#ifdef ARCHICAD
-		/*!
-		 Get the (immutable) API attribute header data
-		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		const API_Attr_Head& getHead() const override;
-#endif
-		
-		// MARK: - Functions (mutating)
-
-#ifdef ARCHICAD
-		/*!
-		 Get the (mutable) API attribute header data
-		 @return The attribute header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		API_Attr_Head& getHead() override;
-#endif
-
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		 */
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		 */
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		/*!
-		 Set to the default package content
-		 */
-		void setDefault() override;
-		
-	private:
-		/*!
-		 Confirm the internal data, either loading from the BIM application or setting a default
-		 */
-		void confirmData() const;
-		
-		class Data;
-			///The attribute data - mutable to support lazy loading
-		mutable std::unique_ptr<Data> m_data;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ATTRIBUTE_MATERIAL
@@ -1,8 +1,15 @@
 #include "Speckle/Record/Element/Beam.h"

+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
+#include "Speckle/Utility/Guid.h"

 using namespace active::serialise;
+using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -17,11 +24,12 @@ namespace speckle::record::element {
 		friend class Beam;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{elem.beam} {}
+		Data(const API_Element& elem) : root{ std::make_unique<API_BeamType>(elem.beam) } {}
+		Data(const Data& source) : root{ std::make_unique<API_BeamType>(*source.root) } {}
 #endif

 	private:
-		API_BeamType root;
+		std::unique_ptr<API_BeamType> root;
 	};

 }
@@ -83,7 +91,7 @@ Beam::~Beam() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& Beam::getHead() const {
-	return m_data->root.head;
+	return m_data->root->head;
 } //Beam::getHead

 /*--------------------------------------------------------------------
@@ -92,7 +100,7 @@ const API_Elem_Head& Beam::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& Beam::getHead() {
-	return m_data->root.head;
+	return m_data->root->head;
 } //Beam::getHead


@@ -1,17 +1,21 @@
 #include "Speckle/Record/Element/BeamSegment.h"

-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
+#include "Speckle/Utility/Guid.h"

 #ifdef ARCHICAD
 #include <ACAPinc.h>
 #endif

 using namespace active::serialise;
+using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
 using namespace speckle::utility;

 #include <array>
@@ -24,10 +28,11 @@ namespace speckle::record::element {
 		friend class BeamSegment;

 #ifdef ARCHICAD
-		Data(const API_BeamSegmentType& seg) : root{seg} {}
+		Data(const API_BeamSegmentType& seg) : root{ std::make_unique<API_BeamSegmentType>(seg) } {}
+		Data(const Data& source) : root{ std::make_unique<API_BeamSegmentType>(*source.root) } {}

 	private:
-		API_BeamSegmentType root;
+		std::unique_ptr<API_BeamSegmentType> root;
 #endif
 	};

@@ -97,46 +102,6 @@ BeamSegment::BeamSegment(BeamSegment&& source) noexcept : base{source} {
 BeamSegment::~BeamSegment() {}


-/*--------------------------------------------------------------------
-	Get the composition of materials in the element
- 
-	return: The material composition (element with ordered material composition should override)
-  --------------------------------------------------------------------*/
-ModelElement::Composition BeamSegment::getComposition() const {
-#ifdef ARCHICAD
-	return convert(m_data->root.assemblySegmentData.modelElemStructureType);
-#endif
-} //BeamSegment::getComposition
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> BeamSegment::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.assemblySegmentData.buildingMaterial.GenerateHashValue())}};
-#endif
-} //BeamSegment::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure BeamSegment::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().beamSegment.rightSurface);
-	BIMMemory::setMask(&surveyor.elementMask().beamSegment.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().beamSegment.rightSurface, surveyor.quantity().beamSegment.volume};
-#endif
-} //BeamSegment::getSpatialMeasure
-
-
 #ifdef ARCHICAD
 /*--------------------------------------------------------------------
 	Get the (immutable) API element header data
@@ -144,7 +109,7 @@ ModelElement::SpatialMeasure BeamSegment::getSpatialMeasure() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& BeamSegment::getHead() const {
-	return m_data->root.head;
+	return m_data->root->head;
 } //BeamSegment::getHead


@@ -154,7 +119,7 @@ const API_Elem_Head& BeamSegment::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& BeamSegment::getHead() {
-	return m_data->root.head;
+	return m_data->root->head;
 } //BeamSegment::getHead
 #endif

@@ -64,21 +64,6 @@ namespace speckle::record::element {

 		// MARK: - Functions (const)

-		/*!
-		 Get the composition of materials in the element
-		 @return The material composition (element with ordered material composition should override)
-		 */
-		Composition getComposition() const override;
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
 #ifdef ARCHICAD
 		/*!
 		 Get the (immutable) API element header data
@@ -1,8 +1,15 @@
 #include "Speckle/Record/Element/Column.h"

+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
+#include "Speckle/Utility/Guid.h"

 using namespace active::serialise;
+using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -17,11 +24,12 @@ namespace speckle::record::element {
 		friend class Column;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{elem.column} {}
+		Data(const API_Element& elem) : root{ std::make_unique<API_ColumnType>(elem.column) } {}
+		Data(const Data& source) : root{ std::make_unique<API_ColumnType>(*source.root) } {}
 #endif

 	private:
-		API_ColumnType root;
+		std::unique_ptr<API_ColumnType> root;
 	};

 }
@@ -83,7 +91,7 @@ Column::~Column() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& Column::getHead() const {
-	return m_data->root.head;
+	return m_data->root->head;
 } //Column::getHead

 /*--------------------------------------------------------------------
@@ -92,7 +100,7 @@ const API_Elem_Head& Column::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& Column::getHead() {
-	return m_data->root.head;
+	return m_data->root->head;
 } //Column::getHead


@@ -1,17 +1,21 @@
 #include "Speckle/Record/Element/ColumnSegment.h"

-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
+#include "Speckle/Utility/Guid.h"

 #ifdef ARCHICAD
 #include <ACAPinc.h>
 #endif

 using namespace active::serialise;
+using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
 using namespace speckle::utility;

 #include <array>
@@ -24,10 +28,11 @@ namespace speckle::record::element {
 		friend class ColumnSegment;

 #ifdef ARCHICAD
-		Data(const API_ColumnSegmentType& seg) : root{seg} {}
+		Data(const API_ColumnSegmentType& seg) : root{ std::make_unique<API_ColumnSegmentType>(seg) } {}
+		Data(const Data& source) : root{ std::make_unique<API_ColumnSegmentType>(*source.root) } {}

 	private:
-		API_ColumnSegmentType root;
+		std::unique_ptr<API_ColumnSegmentType> root;
 #endif
 	};

@@ -97,46 +102,6 @@ ColumnSegment::ColumnSegment(ColumnSegment&& source) noexcept : base{source} {
 ColumnSegment::~ColumnSegment() {}


-/*--------------------------------------------------------------------
-	Get the composition of materials in the element
- 
-	return: The material composition (element with ordered material composition should override)
-  --------------------------------------------------------------------*/
-ModelElement::Composition ColumnSegment::getComposition() const {
-#ifdef ARCHICAD
-	return convert(m_data->root.assemblySegmentData.modelElemStructureType);
-#endif
-} //ColumnSegment::getComposition
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> ColumnSegment::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.assemblySegmentData.buildingMaterial.GenerateHashValue())}};
-#endif
-} //ColumnSegment::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure ColumnSegment::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().columnSegment.coreNetSurface);
-	BIMMemory::setMask(&surveyor.elementMask().columnSegment.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().columnSegment.coreNetSurface, surveyor.quantity().columnSegment.volume};
-#endif
-} //ColumnSegment::getSpatialMeasure
-
-
 #ifdef ARCHICAD
 /*--------------------------------------------------------------------
 	Get the (immutable) API element header data
@@ -144,7 +109,7 @@ ModelElement::SpatialMeasure ColumnSegment::getSpatialMeasure() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& ColumnSegment::getHead() const {
-	return m_data->root.head;
+	return m_data->root->head;
 } //ColumnSegment::getHead


@@ -154,7 +119,7 @@ const API_Elem_Head& ColumnSegment::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& ColumnSegment::getHead() {
-	return m_data->root.head;
+	return m_data->root->head;
 } //ColumnSegment::getHead
 #endif

@@ -64,21 +64,6 @@ namespace speckle::record::element {

 		// MARK: - Functions (const)

-		/*!
-		 Get the composition of materials in the element
-		 @return The material composition (element with ordered material composition should override)
-		 */
-		Composition getComposition() const override;
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
 #ifdef ARCHICAD
 		/*!
 		 Get the (immutable) API element header data
@@ -1,6 +1,15 @@
 #include "Speckle/Record/Element/DrawingElement.h"

+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
+#include "Speckle/Utility/Guid.h"
+
 using namespace active::serialise;
+using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -1,15 +1,17 @@
 #include "Speckle/Record/Element/Element.h"

+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Speckle/Database/BIMElementDatabase.h"
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/Environment/Project.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
 #include "Speckle/Record/Element/Memo.h"
-#include "Speckle/Record/Element/Setting/TypeSetting.h"
 #include "Speckle/SpeckleResource.h"
-#include "Active/Serialise/CargoHold.h"
+#include "Speckle/Utility/Guid.h"

 using namespace active::serialise;
-using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
@@ -17,100 +19,6 @@ using namespace speckle::utility;

 #include <array>
 #include <memory>
-#include <string>
-
-namespace {
-    ///Serialisation fields
-    enum FieldIndex {
-        applicationTypeD,
-    };
-
-    ///Serialisation field IDs
-    static std::array fieldID = {
-        Identity{"applicationType"},
-    };
-
-#ifdef ARCHICAD
-    String GetElemTypeName(API_ElemTypeID elemTypeID) {
-        switch (elemTypeID) {
-        case API_WallID: return "Wall";
-        case API_ColumnID: return "Column";
-        case API_BeamID: return "Beam";
-        case API_WindowID: return "Window";
-        case API_DoorID: return "Door";
-        case API_ObjectID: return "Object";
-        case API_LampID: return "Lamp";
-        case API_SlabID: return "Slab";
-        case API_RoofID: return "Roof";
-        case API_MeshID: return "Mesh";
-        case API_DimensionID: return "Dimension";
-        case API_RadialDimensionID: return "RadialDimension";
-        case API_LevelDimensionID: return "LevelDimension";
-        case API_AngleDimensionID: return "AngleDimension";
-        case API_TextID: return "Text";
-        case API_LabelID: return "Label";
-        case API_ZoneID: return "Zone";
-        case API_HatchID: return "Hatch";
-        case API_LineID: return "Line";
-        case API_PolyLineID: return "PolyLine";
-        case API_ArcID: return "Arc";
-        case API_CircleID: return "Circle";
-        case API_SplineID: return "Spline";
-        case API_HotspotID: return "Hotspot";
-        case API_CutPlaneID: return "CutPlane";
-        case API_CameraID: return "Camera";
-        case API_CamSetID: return "CamSet";
-        case API_GroupID: return "Group";
-        case API_SectElemID: return "SectElem";
-        case API_DrawingID: return "Drawing";
-        case API_PictureID: return "Picture";
-        case API_DetailID: return "Detail";
-        case API_ElevationID: return "Elevation";
-        case API_InteriorElevationID: return "InteriorElevation";
-        case API_WorksheetID: return "Worksheet";
-        case API_HotlinkID: return "Hotlink";
-        case API_CurtainWallID: return "CurtainWall";
-        case API_CurtainWallSegmentID: return "CurtainWallSegment";
-        case API_CurtainWallFrameID: return "CurtainWallFrame";
-        case API_CurtainWallPanelID: return "CurtainWallPanel";
-        case API_CurtainWallJunctionID: return "CurtainWallJunction";
-        case API_CurtainWallAccessoryID: return "CurtainWallAccessory";
-        case API_ShellID: return "Shell";
-        case API_SkylightID: return "Skylight";
-        case API_MorphID: return "Morph";
-        case API_ChangeMarkerID: return "ChangeMarker";
-        case API_StairID: return "Stair";
-        case API_RiserID: return "Riser";
-        case API_TreadID: return "Tread";
-        case API_StairStructureID: return "StairStructure";
-        case API_RailingID: return "Railing";
-        case API_RailingToprailID: return "RailingToprail";
-        case API_RailingHandrailID: return "RailingHandrail";
-        case API_RailingRailID: return "RailingRail";
-        case API_RailingPostID: return "RailingPost";
-        case API_RailingInnerPostID: return "RailingInnerPost";
-        case API_RailingBalusterID: return "RailingBaluster";
-        case API_RailingPanelID: return "RailingPanel";
-        case API_RailingSegmentID: return "RailingSegment";
-        case API_RailingNodeID: return "RailingNode";
-        case API_RailingBalusterSetID: return "RailingBalusterSet";
-        case API_RailingPatternID: return "RailingPattern";
-        case API_RailingToprailEndID: return "RailingToprailEnd";
-        case API_RailingHandrailEndID: return "RailingHandrailEnd";
-        case API_RailingRailEndID: return "RailingRailEnd";
-        case API_RailingToprailConnectionID: return "RailingToprailConnection";
-        case API_RailingHandrailConnectionID: return "RailingHandrailConnection";
-        case API_RailingRailConnectionID: return "RailingRailConnection";
-        case API_RailingEndFinishID: return "RailingEndFinish";
-        case API_BeamSegmentID: return "BeamSegment";
-        case API_ColumnSegmentID: return "ColumnSegment";
-        case API_OpeningID: return "Opening";
-        case API_ExternalElemID: return "ExternalElem";
-        default: return "UnknownElemType";
-        }
-    }
-#endif
-}

 /*--------------------------------------------------------------------
 	Default constructor
@@ -167,42 +75,17 @@ Storey::Option Element::getStorey() const {


 /*--------------------------------------------------------------------
-	Get a link to the BIM record
- 
-	return: The BIM record link
-  --------------------------------------------------------------------*/
-BIMLink Element::getBIMLink() const {
-	auto result = base::getBIMLink();
-#ifdef ARCHICAD
-	result.emplace_back(std::make_unique<TypeSetting>(getHead()));
-#endif
-	return result;
-} //Element::getLink
-
-
-/*--------------------------------------------------------------------
-	Get the localised element type name, e.g. "Wall", "Roof" etc
+	Get the element type name, e.g. "Wall", "Roof" etc

 	return: The type name
  --------------------------------------------------------------------*/
-String Element::getLocalisedTypeName() const {
+String Element::getTypeName() const {
 #ifdef ARCHICAD
 	GS::UniString typeName;
 	if (auto err = ACAPI_Element_GetElemTypeName(getHead().type, typeName); err != NoError)
 		return addon()->getLocalString(titleStringLib, unknownElementTypeID);
 	return typeName;
 #endif
-} //Element::getLocalisedTypeName
-
-
-/*--------------------------------------------------------------------
-	Get the element type name, e.g. "Wall", "Roof" etc
-
-	return: The type name
-  --------------------------------------------------------------------*/
-#include "Speckle/Environment/Platform.h"
-String Element::getTypeName() const {
-    return GetElemTypeName(getHead().type.typeID);
 } //Element::getTypeName


@@ -214,12 +97,6 @@ String Element::getTypeName() const {
 	return: True if the package has added items to the inventory
  --------------------------------------------------------------------*/
 bool Element::fillInventory(Inventory& inventory) const {
-    using enum Entry::Type;
-    inventory.merge(Inventory{
-        {
-            { fieldID[applicationTypeD], applicationTypeD, element },
-        },
-        }.withType(&typeid(Element)));
 	return base::fillInventory(inventory);
 } //Element::fillInventory

@@ -232,15 +109,7 @@ bool Element::fillInventory(Inventory& inventory) const {
 	return: The requested cargo (nullptr on failure)
  --------------------------------------------------------------------*/
 Cargo::Unique Element::getCargo(const Inventory::Item& item) const {
-    if (item.ownerType != &typeid(Element))
-        return base::getCargo(item);
-    using namespace active::serialise;
-    switch (item.index) {
-        case applicationTypeD:
-            return Cargo::Unique{ new CargoHold<ValueWrap<String>, String>{ getTypeName() } };
-        default:
-            return nullptr;	//Requested an unknown index
-    }
+		return base::getCargo(item);
 } //Element::getCargo


@@ -62,12 +62,7 @@ namespace speckle::record::element {
 		// MARK: - Functions (const)

 		/*!
-		 Get the localised element type name, e.g. "Wall", "Roof" etc
-		 @return The type name
-		 */
-		virtual speckle::utility::String getLocalisedTypeName() const;
-		/*!
-		 Get the element type name, e.g. "Wall", "Roof" etc
+		 Get the elmeent type name, e.g. "Wall", "Roof" etc
 		 @return The type name
 		 */
 		virtual speckle::utility::String getTypeName() const;
@@ -76,11 +71,6 @@ namespace speckle::record::element {
 		 @return The element storey (nullopt if the element isn't linked to a storey)
 		 */
 		virtual attribute::Storey::Option getStorey() const;
-		/*!
-		 Get a link to the BIM record
-		 @return The BIM record link
-		 */
-		database::BIMLink getBIMLink() const override;
 #ifdef ARCHICAD
 		/*!
 		 Get the (immutable) API element header data
@@ -1,6 +1,15 @@
 #include "Speckle/Record/Element/GenericDrawingElement.h"

+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
+#include "Speckle/Utility/Guid.h"
+
 using namespace active::serialise;
+using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -15,11 +24,12 @@ namespace speckle::record::element {
 		friend class GenericDrawingElement;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{elem} {}
+		Data(const API_Element& elem) : root{ std::make_unique<API_Element>(elem) } {}
+		Data(const Data& source) : root{ std::make_unique<API_Element>(*source.root) } {}
 #endif

 	private:
-		API_Element root;
+		std::unique_ptr<API_Element> root;
 	};

 }
@@ -65,7 +75,7 @@ GenericDrawingElement::~GenericDrawingElement() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& GenericDrawingElement::getHead() const {
-	return m_data->root.header;
+	return m_data->root->header;
 } //GenericDrawingElement::getHead

 /*--------------------------------------------------------------------
@@ -74,7 +84,7 @@ const API_Elem_Head& GenericDrawingElement::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& GenericDrawingElement::getHead() {
-	return m_data->root.header;
+	return m_data->root->header;
 } //GenericDrawingElement::getHead
 #endif

@@ -1,6 +1,15 @@
 #include "Speckle/Record/Element/GenericModelElement.h"

+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/SpeckleResource.h"
+#include "Speckle/Utility/Guid.h"
+
 using namespace active::serialise;
+using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
 using namespace speckle::utility;
@@ -15,11 +24,12 @@ namespace speckle::record::element {
 		friend class GenericModelElement;

 #ifdef ARCHICAD
-		Data(const API_Element& elem) : root{elem} {}
+		Data(const API_Element& elem) : root{ std::make_unique<API_Element>(elem) } {}
+		Data(const Data& source) : root{ std::make_unique<API_Element>(*source.root) } {}
 #endif

 	private:
-		API_Element root;
+		std::unique_ptr<API_Element> root;
 	};

 }
@@ -65,7 +75,7 @@ GenericModelElement::~GenericModelElement() {}
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 const API_Elem_Head& GenericModelElement::getHead() const {
-	return m_data->root.header;
+	return m_data->root->header;
 } //GenericModelElement::getHead

 /*--------------------------------------------------------------------
@@ -74,7 +84,7 @@ const API_Elem_Head& GenericModelElement::getHead() const {
 	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
  --------------------------------------------------------------------*/
 API_Elem_Head& GenericModelElement::getHead() {
-	return m_data->root.header;
+	return m_data->root->header;
 } //GenericModelElement::getHead
 #endif

@@ -1,164 +0,0 @@
-#include "Speckle/Record/Element/MeshElem.h"
-
-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
-
-#ifdef ARCHICAD
-#include <ACAPinc.h>
-#endif
-
-using namespace active::serialise;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
-using namespace speckle::utility;
-
-#include <array>
-#include <memory>
-
-namespace speckle::record::element {
-
-	class Mesh::Data {
-	public:
-		friend class Mesh;
-
-#ifdef ARCHICAD
-		Data(const API_MeshType& seg) : root{seg} {}
-
-	private:
-		API_MeshType root;
-#endif
-	};
-
-}
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Mesh::Mesh() {
-} //Mesh::Mesh
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Constructor
-
-	elemData: Archicad element data
-	tableID: The element table ID (AC database, e.g. floor plan, 3D)
-  --------------------------------------------------------------------*/
-Mesh::Mesh(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
-	m_data = std::make_unique<Data>(elemData.mesh);
-} //Mesh::Mesh
-#endif
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
-
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Mesh::Mesh(const Mesh& source) : base{ source } {
-	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-} //Mesh::Mesh
-
-
-/*--------------------------------------------------------------------
-	Move constructor
-
-	source: The object to move
-  --------------------------------------------------------------------*/
-Mesh::Mesh(Mesh&& source) noexcept : base{source} {
-	m_data = std::move(source.m_data);
-} //Mesh::Mesh
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-Mesh::~Mesh() {}
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> Mesh::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
-#endif
-} //Mesh::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure Mesh::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().mesh.topSurface);
-	BIMMemory::setMask(&surveyor.elementMask().mesh.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().mesh.topSurface, surveyor.quantity().mesh.volume};
-#endif
-} //Mesh::getSpatialMeasure
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Get the (immutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-const API_Elem_Head& Mesh::getHead() const {
-	return m_data->root.head;
-} //Mesh::getHead
-
-
-/*--------------------------------------------------------------------
-	Get the (mutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-API_Elem_Head& Mesh::getHead() {
-	return m_data->root.head;
-} //Mesh::getHead
-#endif
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
-
-	inventory: The inventory to receive the package items
-
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool Mesh::fillInventory(Inventory& inventory) const {
-	using enum Entry::Type;
-		//TODO: Implement other fields as required
-	return base::fillInventory(inventory);
-} //Mesh::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
-
-	item: The inventory item to retrieve
-
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique Mesh::getCargo(const Inventory::Item& item) const {
-		//TODO: Implement other fields as required
-	return base::getCargo(item);
-} //Mesh::getCargo
-
-
-/*--------------------------------------------------------------------
-	Set to the default package content
-  --------------------------------------------------------------------*/
-void Mesh::setDefault() {
-	m_data.reset();
-} //Mesh::setDefault
@@ -1,120 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_MESH
-#define SPECKLE_RECORD_ELEMENT_MESH
-
-#include "Speckle/Record/Element/ModelElement.h"
-#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
-
-namespace speckle::record::element {
-	
-	/*!
-	 BIM mesh class
-	 */
-	class Mesh : public ModelElement {
-	public:
-
-		// MARK: - Types
-		
-		using base = ModelElement;
-			///Unique pointer
-		using Unique = std::unique_ptr<Mesh>;
-			///Shared pointer
-		using Shared = std::shared_ptr<Mesh>;
-			///Optional
-		using Option = std::optional<Mesh>;
-
-		// MARK: - Constructors
-		
-		using base::base;
-		
-		/*!
-		 Default constructor
-		 */
-		Mesh();
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param elemData Archicad element data
-		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
-		 */
-		Mesh(const API_Element& elemData, const speckle::utility::Guid& tableID);
-#endif
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Mesh(const Mesh& source);
-		/*!
-		 Move constructor
-		 @param source The object to move
-		 */
-		Mesh(Mesh&& source) noexcept;
-		/*!
-		 Destructor
-		 */
-		~Mesh();
-
-		/*!
-		 Object cloning
-		 @return A clone of this object
-		 */
-		Mesh* clonePtr() const override { return new Mesh{*this}; }
-
-
-		// MARK: - Functions (const)
-
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
-#ifdef ARCHICAD
-		/*!
-		 Get the (immutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		const API_Elem_Head& getHead() const override;
-#endif
-		
-		// MARK: - Functions (mutating)
-
-#ifdef ARCHICAD
-		/*!
-		 Get the (mutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		API_Elem_Head& getHead() override;
-#endif
-
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		 */
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		 */
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		/*!
-		 Set to the default package content
-		 */
-		void setDefault() override;
-		
-	private:
-		class Data;
-			///The beam data
-		std::unique_ptr<Data> m_data;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_MESH
@@ -1,12 +1,13 @@
 #include "Speckle/Record/Element/ModelElement.h"

+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
 #include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/Primitive/Mesh/Mesh.h"
-#include "Speckle/Record/Element/Memo.h"
 #include "Speckle/Record/Property/Wrapper/PropertiedWrapper.h"
 #include "Speckle/SpeckleResource.h"
-#include "Speckle/Utility/BIMMemory.h"
+#include "Speckle/Utility/Guid.h"

 #ifdef ARCHICAD
 #include <exp.h>
@@ -16,6 +17,7 @@
 #include <ModelElement.hpp>
 #include <ModelMaterial.hpp>
 #include <ModelMeshBody.hpp>
+#include <ModelEdge.hpp>
 #include <Sight.hpp>
 #endif

@@ -25,13 +27,14 @@ using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::record::attribute;
 using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
 using namespace speckle::record::property;
 using namespace speckle::utility;

 #include <array>
 #include <memory>

+#include <stack>
+
 namespace speckle::record::element {

 	class ModelElement::Data {
@@ -78,7 +81,6 @@ namespace speckle::record::element {

 	};
 	
-		///Allocation for the ModelElement finishes cache (used because repeated API access is very slow)
 	std::unique_ptr<ModelElement::FinishCache> ModelElement::m_finishCache;
 	
 }
@@ -88,96 +90,76 @@ namespace {
 	///Serialisation fields
 	enum FieldIndex {
 		bodyID,
-		materialQuantsID,
 		propertyID,
 	};

 	///Serialisation field IDs
 	static std::array fieldID = {
 		Identity{"displayValue"},
-		Identity{"materialQuantities"},
 		Identity{"properties"},
 	};
 	
 #ifdef ARCHICAD
-	/*!
-	 Collect the IDs of individual parts from an assembly (e.g. stair, curtain wall)
-	 @param parts A pointer to the assembly parts
-	 @param partIDs The assembly part IDs
-	 */
 	template<typename T>
-	void getPartIDs(T* parts, std::set<API_Guid>& partIDs) {
-		GSSize nSubElements = BMGetPtrSize(reinterpret_cast<GSPtr>(parts)) / sizeof(T);
+	void getSubElementIds(T* ptr, std::set<API_Guid>& subIds)
+	{
+		GSSize nSubElements = BMGetPtrSize(reinterpret_cast<GSPtr>(ptr)) / sizeof(T);
 		for (Int32 idx = 0; idx < nSubElements; ++idx)
-			partIDs.insert(parts[idx].head.guid);
+			subIds.insert(ptr[idx].head.guid);
 	}
-	
-	
-	/*!
-	 Measure material quantities from the composite materials of a specified element
-	 @param guid The ID of the element to measure
-	 @param elementQuantity Quantities extracted from the target element (out)
-	 @param extendedQuantity Optional extended quantities calculated for some element types
-	 @param quantityMask Mask to determine which quantities are required (minimise calculation time)
-	 */
-	void measureQuantities(const API_Guid& guid, API_ElementQuantity& elementQuantity,
-								  API_Quantities& extendedQuantity, const API_QuantitiesMask& quantityMask) {
-		extendedQuantity.elements = &elementQuantity;
-		GS::Array<API_ElemPartQuantity> elementPartQuantities;
-		API_QuantityPar quantityParameters{};
-		quantityParameters.minOpeningSize = Eps;
-		ACAPI_Element_GetQuantities(guid, &quantityParameters, &extendedQuantity, &quantityMask);
-	} //measureQuantities
-	
-	
-	/*!
-	 Collect the IDs of individual parts from an element (e.g. stair, curtain wall)
-	 @param elemId The element to collect part IDs from
-	 @param typeID The element type identifier
-	 @param memo The element memo data
-	 */
-	std::set<API_Guid> collectPartIDs(const API_Guid& elemId, API_ElemTypeID typeID, const Memo& memo) {
-		std::set<API_Guid> partIDs{};
-		partIDs.insert(elemId);
-		if (!memo)
-			return partIDs;
-		switch (typeID) {
-			case API_StairID:
-				getPartIDs(memo.root()->stairRisers, partIDs);
-				getPartIDs(memo.root()->stairTreads, partIDs);
-				getPartIDs(memo.root()->stairStructures, partIDs);
-				break;
-			case API_RailingID:
-				getPartIDs(memo.root()->railingSegments, partIDs);
-				getPartIDs(memo.root()->railingPatterns, partIDs);
-				getPartIDs(memo.root()->railingRails, partIDs);
-				getPartIDs(memo.root()->railingHandrails, partIDs);
-				getPartIDs(memo.root()->railingToprails, partIDs);
-				getPartIDs(memo.root()->railingBalusterSets, partIDs);
-				getPartIDs(memo.root()->railingBalusters, partIDs);
-				getPartIDs(memo.root()->railingPanels, partIDs);
-				getPartIDs(memo.root()->railingInnerPosts, partIDs);

-				getPartIDs(memo.root()->railingNodes, partIDs);
-				getPartIDs(memo.root()->railingRailConnections, partIDs);
-				getPartIDs(memo.root()->railingHandrailConnections, partIDs);
-				getPartIDs(memo.root()->railingToprailConnections, partIDs);
-				getPartIDs(memo.root()->railingPosts, partIDs);
-				getPartIDs(memo.root()->railingRailEnds, partIDs);
-				getPartIDs(memo.root()->railingHandrailEnds, partIDs);
-				getPartIDs(memo.root()->railingToprailEnds, partIDs);
-				break;
-			case API_CurtainWallID:
-				getPartIDs(memo.root()->cWallSegments, partIDs);
-				getPartIDs(memo.root()->cWallFrames, partIDs);
-				getPartIDs(memo.root()->cWallPanels, partIDs);
-				getPartIDs(memo.root()->cWallJunctions, partIDs);
-				getPartIDs(memo.root()->cWallAccessories, partIDs);
-				break;
-			default:
-				break;
+	std::set<API_Guid> collectSubIds(API_Guid elemId)
+	{
+		API_Element	elem{};
+		elem.header.guid = elemId;
+		ACAPI_Element_Get(&elem);
+		API_ElementMemo memo{};
+		ACAPI_Element_GetMemo(elemId, &memo);
+
+		std::set<API_Guid> subIds{};
+		subIds.insert(elemId);
+
+		if (elem.header.type.typeID == API_StairID)
+		{
+			getSubElementIds(memo.stairRisers, subIds);
+			getSubElementIds(memo.stairTreads, subIds);
+			getSubElementIds(memo.stairStructures, subIds);
 		}
-		return partIDs;
+
+		if (elem.header.type.typeID == API_RailingID)
+		{
+			// segments
+			getSubElementIds(memo.railingSegments, subIds);
+			getSubElementIds(memo.railingPatterns, subIds);
+			getSubElementIds(memo.railingRails, subIds);
+			getSubElementIds(memo.railingHandrails, subIds);
+			getSubElementIds(memo.railingToprails, subIds);
+			getSubElementIds(memo.railingBalusterSets, subIds);
+			getSubElementIds(memo.railingBalusters, subIds);
+			getSubElementIds(memo.railingPanels, subIds);
+			getSubElementIds(memo.railingInnerPosts, subIds);
+
+			// nodes
+			getSubElementIds(memo.railingNodes, subIds);
+			getSubElementIds(memo.railingRailConnections, subIds);
+			getSubElementIds(memo.railingHandrailConnections, subIds);
+			getSubElementIds(memo.railingToprailConnections, subIds);
+			getSubElementIds(memo.railingPosts, subIds);
+			getSubElementIds(memo.railingRailEnds, subIds);
+			getSubElementIds(memo.railingHandrailEnds, subIds);
+			getSubElementIds(memo.railingToprailEnds, subIds);
+		}
+
+		if (elem.header.type.typeID == API_CurtainWallID)
+		{
+			getSubElementIds(memo.cWallSegments, subIds);
+			getSubElementIds(memo.cWallFrames, subIds);
+			getSubElementIds(memo.cWallPanels, subIds);
+			getSubElementIds(memo.cWallJunctions, subIds);
+			getSubElementIds(memo.cWallAccessories, subIds);
+		}
+
+		return subIds;
 	}
 #endif
 	
@@ -254,52 +236,6 @@ void ModelElement::resetCache() {
 } //ModelElement::resetCache


-/*--------------------------------------------------------------------
-	Get material quantities measured from this element
- 
-	return: An list of material quantities
-  --------------------------------------------------------------------*/
-MaterialQuantityList ModelElement::getMaterialQuantities() const {
-	using enum Composition;
-	MaterialQuantityList result;
-	switch (getComposition()) {
-		case unordered: {
-				//Get the material and spatial measurements
-			auto material = getMaterial();
-			if (!material)
-				return result;
-			auto spatialMeasure = getSpatialMeasure();
-			if (!spatialMeasure)
-				return result;
-				//Create a material quantity from the quantity takeoff
-			result.push_back({material->getBIMID(), spatialMeasure.area, spatialMeasure.volume});
-			break;
-		}
-		case skinned: {
-#ifdef ARCHICAD
-			API_ElementQuantity elementQuantity{};
-			API_Quantities extendedQuantity{};
-			GS::Array<API_CompositeQuantity> compositeQuantity{};
-			extendedQuantity.composites = &compositeQuantity;
-			API_QuantitiesMask quantityMask{};
-				//Set the appropriate masks for composite material volume/area quantity takeoffs
-			BIMMemory::setMask(&quantityMask.composites.buildMatIndices);
-			BIMMemory::setMask(&quantityMask.composites.volumes);
-			BIMMemory::setMask(&quantityMask.composites.projectedArea);
-			measureQuantities(getHead().guid, elementQuantity, extendedQuantity, quantityMask);
-				//Create material quantities from the quantity takeoff (one oer skin in the composite structure)
-			for (auto& skinQuant : compositeQuantity)
-				result.push_back({Guid{Guid::fromInt(skinQuant.buildMatIndices.GenerateHashValue())}, skinQuant.projectedArea, skinQuant.volumes});
-#endif
-			break;
-		}
-		case profiled:
-			break;
-	}
-	return result;
-} //ModelElement::getMaterialQuantities
-
-
 /*--------------------------------------------------------------------
 	Get the element body as a list of faces or Meshes

@@ -307,6 +243,8 @@ MaterialQuantityList ModelElement::getMaterialQuantities() const {
  --------------------------------------------------------------------*/
 ModelElement::Body* ModelElement::getBody() const {
 #ifdef ARCHICAD
+	ModelerAPI::Material tmpmat{};
+
 	if (m_data && m_data->m_cache)
 		return m_data->m_cache.get();
 	void* dummy = nullptr;
@@ -324,18 +262,13 @@ ModelElement::Body* ModelElement::getBody() const {
 	auto elementBody = new ModelElement::Body();
 	// Map to collect meshes per material name
 	std::unordered_map<String, primitive::Mesh> materialMeshMap;
-
-	std::unique_ptr<Memo> memo;
-	loadMemo(APIMemoMask_All, memo);
-
-    auto partIDs = collectPartIDs(getHead().guid, getHead().type.typeID, *memo);
-	memo.reset();
+    auto subIds = collectSubIds(getHead().guid);
 	Int32 nElements = acModel.GetElementCount();
 	for (Int32 iElement = 1; iElement <= nElements; iElement++) {
 		ModelerAPI::Element elem{};
 		acModel.GetElement(iElement, &elem);
 		API_Guid apiGuid{GSGuid2APIGuid(elem.GetElemGuid())};
-		if (partIDs.find(apiGuid) == partIDs.end())
+		if (subIds.find(apiGuid) == subIds.end())
 			continue;
 		Int32 nBodies = elem.GetTessellatedBodyCount();
 		ModelerAPI::Material material{};
@@ -343,6 +276,52 @@ ModelElement::Body* ModelElement::getBody() const {
 			ModelerAPI::MeshBody body{};
 			elem.GetTessellatedBody(bodyIndex, &body);
 			Int32 polyCount = body.GetPolygonCount();
+
+			if (polyCount == 0)
+			{
+				std::vector<int> vertexIndices;
+				
+				Int32 edgeCount = body.GetEdgeCount();
+				ModelerAPI::Edge edge{};
+				for (Int32 edgeIndex = 1; edgeIndex <= edgeCount; ++edgeIndex)
+				{
+					body.GetEdge(edgeIndex, &edge);
+					vertexIndices.push_back(edge.GetVertexIndex1());
+					vertexIndices.push_back(edge.GetVertexIndex2());
+				}
+				vertexIndices.push_back(edge.GetVertexIndex2());
+				vertexIndices.push_back(edge.GetVertexIndex2());
+
+				for (int i = 0; i < vertexIndices.size(); i += 2) {
+					ModelerAPI::Vertex v1{};
+					ModelerAPI::Vertex v2{};
+					body.GetVertex(vertexIndices[i], &v1);
+					body.GetVertex(vertexIndices[i + 1], &v2);
+
+					std::vector<double> points{};
+
+					points.push_back(v1.x);
+					points.push_back(v1.y);
+					points.push_back(v1.z);
+
+					points.push_back(v2.x);
+					points.push_back(v2.y);
+					points.push_back(v2.z);
+
+					points.push_back(v2.x);
+					points.push_back(v2.y);
+					points.push_back(v2.z);
+
+					record::attribute::Finish f(tmpmat);
+					primitive::Mesh mesh(std::move(points), f);
+					mesh.setToPolyline();
+					elementBody->push_back(mesh);
+
+					points.clear();
+				}
+			}
+
+
 			for (Int32 polyIndex = 1; polyIndex <= polyCount; ++polyIndex) {
 				ModelerAPI::Polygon polygon{};
 				body.GetPolygon(polyIndex, &polygon);
@@ -353,6 +332,8 @@ ModelElement::Body* ModelElement::getBody() const {
 				if (faceFinish == nullptr) {
 					ModelerAPI::Material material{};
 					polygon.GetMaterial(&material);
+					///
+					tmpmat = material;
 					Finish finish{material};
 					faceFinish = ModelElement::cacheFinish(finishID, finish);
 				}
@@ -380,6 +361,13 @@ ModelElement::Body* ModelElement::getBody() const {
 	}
 	for (auto& [materialName, mesh] : materialMeshMap)
 		elementBody->push_back(std::move(mesh));
+
+	/*std::vector<double> points = {0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0};
+	record::attribute::Finish f(tmpmat);
+	primitive::Mesh mesh(std::move(points), f);
+	mesh.setToPolyline();
+	elementBody->push_back(mesh);*/
+
 	m_data = std::make_unique<Data>();
 	m_data->m_cache.reset(elementBody);
 	return m_data->m_cache.get();
@@ -399,7 +387,6 @@ bool ModelElement::fillInventory(Inventory& inventory) const {
 	inventory.merge(Inventory{
 		{
 			{ fieldID[bodyID], bodyID, element },
-			{ fieldID[materialQuantsID], materialQuantsID, element },
 			{ fieldID[propertyID], propertyID, element },
 		},
 	}.withType(&typeid(ModelElement)));
@@ -421,12 +408,9 @@ Cargo::Unique ModelElement::getCargo(const Inventory::Item& item) const {
 	switch (item.index) {
 		case bodyID:
 			if (auto body = getBody(); body != nullptr)
-				return Cargo::Unique{new active::serialise::ContainerWrap{*body}};
-			return nullptr;
-		case materialQuantsID:
-			if (auto quants = getMaterialQuantities(); !quants.empty())
-				return Cargo::Unique{new CargoHold<ContainerWrap<MaterialQuantityList>, MaterialQuantityList>{quants}};
-			return nullptr;
+				return Cargo::Unique{ new active::serialise::ContainerWrap{*body} };
+			else
+				return nullptr;
 		case propertyID:
 			return std::make_unique<PropertiedWrapper>(*this);
 		default:
@@ -1,15 +1,13 @@
 #ifndef SPECKLE_RECORD_MODEL_ELEMENT
 #define SPECKLE_RECORD_MODEL_ELEMENT

-#include "Speckle/Record/Attribute/Material.h"
 #include "Speckle/Record/Classification/Classified.h"
 #include "Speckle/Record/Element/Element.h"
-#include "Speckle/Record/Element/Quants/MaterialQuantity.h"
+#include "Speckle/Record/Element/Element.h"
 #include "Speckle/Record/Property/Propertied.h"

 namespace speckle::record::attribute {
 	class Finish;
-	class Material;
 }

 namespace speckle::record::element {
@@ -31,23 +29,8 @@ namespace speckle::record::element {
 		using Option = std::optional<ModelElement>;
 			///A model element 3D body primitive
 		using Body = std::vector<primitive::Mesh>;
-			//Material composition
-		enum class Composition {
-			unordered,	///<Element is composed of materials with no fixed relationship
-			skinned,	///<Element is composed of layered materials 'skins', e.g. brick/air/insulation/block in a wall
-			profiled,	///<Element is composed of materials extruded through a profile along a space-curve, e.g. window frames
-		};
-			///Model element spatial measurements
-		struct SpatialMeasure {
-				///Element area
-			double area = 0.0;
-				///Element volume
-			double volume = 0.0;
-				///True if either a volume or area has been measured
-			operator bool() const { return active::math::isGreaterZero(area) || active::math::isGreaterZero(volume); }
-		};
 		
-		// MARK: - Static functions
+		// MARK: - Constructors
 		
 		/*!
 		 Get a mesh finish from the cache
@@ -96,26 +79,6 @@ namespace speckle::record::element {

 		// MARK: - Functions (const)

-		/*!
-		 Get the composition of materials in the element
-		 @return The material composition (element with ordered material composition should override)
-		 */
-		virtual Composition getComposition() const { return Composition::unordered; }
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		virtual std::optional<record::attribute::Material> getMaterial() const { return std::nullopt; }
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		virtual SpatialMeasure getSpatialMeasure() const { return SpatialMeasure{}; }
-		/*!
-		 Get material quantities measured from this element
-		 @return An list of material quantities
-		 */
-		quants::MaterialQuantityList getMaterialQuantities() const;
 		/*!
 		 Get the element body
 		 @return An array of meshes from the element body (nullptr if no body data is available)
@@ -1,164 +0,0 @@
-#include "Speckle/Record/Element/Morph.h"
-
-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
-
-#ifdef ARCHICAD
-#include <ACAPinc.h>
-#endif
-
-using namespace active::serialise;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
-using namespace speckle::utility;
-
-#include <array>
-#include <memory>
-
-namespace speckle::record::element {
-
-	class Morph::Data {
-	public:
-		friend class Morph;
-
-#ifdef ARCHICAD
-		Data(const API_MorphType& seg) : root{seg} {}
-
-	private:
-		API_MorphType root;
-#endif
-	};
-
-}
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Morph::Morph() {
-} //Morph::Morph
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Constructor
-
-	elemData: Archicad element data
-	tableID: The element table ID (AC database, e.g. floor plan, 3D)
-  --------------------------------------------------------------------*/
-Morph::Morph(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
-	m_data = std::make_unique<Data>(elemData.morph);
-} //Morph::Morph
-#endif
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
-
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Morph::Morph(const Morph& source) : base{ source } {
-	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-} //Morph::Morph
-
-
-/*--------------------------------------------------------------------
-	Move constructor
-
-	source: The object to move
-  --------------------------------------------------------------------*/
-Morph::Morph(Morph&& source) noexcept : base{source} {
-	m_data = std::move(source.m_data);
-} //Morph::Morph
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-Morph::~Morph() {}
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> Morph::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
-#endif
-} //Morph::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure Morph::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().morph.surface);
-	BIMMemory::setMask(&surveyor.elementMask().morph.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().morph.surface, surveyor.quantity().morph.volume};
-#endif
-} //Morph::getSpatialMeasure
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Get the (immutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-const API_Elem_Head& Morph::getHead() const {
-	return m_data->root.head;
-} //Morph::getHead
-
-
-/*--------------------------------------------------------------------
-	Get the (mutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-API_Elem_Head& Morph::getHead() {
-	return m_data->root.head;
-} //Morph::getHead
-#endif
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
-
-	inventory: The inventory to receive the package items
-
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool Morph::fillInventory(Inventory& inventory) const {
-	using enum Entry::Type;
-		//TODO: Implement other fields as required
-	return base::fillInventory(inventory);
-} //Morph::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
-
-	item: The inventory item to retrieve
-
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique Morph::getCargo(const Inventory::Item& item) const {
-		//TODO: Implement other fields as required
-	return base::getCargo(item);
-} //Morph::getCargo
-
-
-/*--------------------------------------------------------------------
-	Set to the default package content
-  --------------------------------------------------------------------*/
-void Morph::setDefault() {
-	m_data.reset();
-} //Morph::setDefault
@@ -1,120 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_MORPH
-#define SPECKLE_RECORD_ELEMENT_MORPH
-
-#include "Speckle/Record/Element/ModelElement.h"
-#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
-
-namespace speckle::record::element {
-	
-	/*!
-	 BIM morph class
-	 */
-	class Morph : public ModelElement {
-	public:
-
-		// MARK: - Types
-		
-		using base = ModelElement;
-			///Unique pointer
-		using Unique = std::unique_ptr<Morph>;
-			///Shared pointer
-		using Shared = std::shared_ptr<Morph>;
-			///Optional
-		using Option = std::optional<Morph>;
-
-		// MARK: - Constructors
-		
-		using base::base;
-		
-		/*!
-		 Default constructor
-		 */
-		Morph();
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param elemData Archicad element data
-		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
-		 */
-		Morph(const API_Element& elemData, const speckle::utility::Guid& tableID);
-#endif
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Morph(const Morph& source);
-		/*!
-		 Move constructor
-		 @param source The object to move
-		 */
-		Morph(Morph&& source) noexcept;
-		/*!
-		 Destructor
-		 */
-		~Morph();
-
-		/*!
-		 Object cloning
-		 @return A clone of this object
-		 */
-		Morph* clonePtr() const override { return new Morph{*this}; }
-
-
-		// MARK: - Functions (const)
-
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
-#ifdef ARCHICAD
-		/*!
-		 Get the (immutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		const API_Elem_Head& getHead() const override;
-#endif
-		
-		// MARK: - Functions (mutating)
-
-#ifdef ARCHICAD
-		/*!
-		 Get the (mutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		API_Elem_Head& getHead() override;
-#endif
-
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		 */
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		 */
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		/*!
-		 Set to the default package content
-		 */
-		void setDefault() override;
-		
-	private:
-		class Data;
-			///The beam data
-		std::unique_ptr<Data> m_data;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_MORPH
@@ -1,78 +0,0 @@
-#include "Speckle/Record/Element/Quants/MaterialQuantity.h"
-
-#include "Active/Serialise/Item/Wrapper/ValueOptionWrap.h"
-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Speckle/Record/Attribute/Material.h"
-#include "Speckle/Record/Element/Quants/MaterialWrap.h"
-#include "Speckle/Serialise/Types/Units/LengthUnit.h"
-
-using namespace active::serialise;
-using namespace speckle::database;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element::quants;
-
-namespace {
-
-	///Serialisation fields
-	enum FieldIndex {
-		areaID,
-		volumeID,
-		unitID,
-		matID,
-	};
-
-	///Serialisation field IDs
-	static std::array fieldID = {
-		Identity{"area"},
-		Identity{"volume"},
-		Identity{"units"},
-		Identity{"material"},
-	};
-	
-}
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the cargo items
- 
-	inventory: The inventory to receive the cargo items
- 
-	return: True if items have been added to the inventory
-  --------------------------------------------------------------------*/
-bool MaterialQuantity::fillInventory(active::serialise::Inventory& inventory) const {
-	using enum Entry::Type;
-	inventory.merge(Inventory{
-		{
-			{ fieldID[areaID], areaID, element },
-			{ fieldID[volumeID], volumeID, element },
-			{ fieldID[unitID], unitID, element },
-			{ fieldID[matID], matID, element },
-		},
-	}.withType(&typeid(MaterialQuantity)));
-	return true;
-} //MaterialQuantity::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
- 
-	item: The inventory item to retrieve
- 
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique MaterialQuantity::getCargo(const active::serialise::Inventory::Item& item) const {
-	if (item.ownerType != &typeid(MaterialQuantity))
-		return nullptr;
-	using namespace active::serialise;
-	switch (item.index) {
-		case areaID:
-			return std::make_unique<ValueWrap<double>>(m_area);
-		case volumeID:
-			return std::make_unique<ValueWrap<double>>(m_volume);
-		case unitID:
-			return std::make_unique<ValueOptionWrap<active::measure::LengthType>>(m_unit);
-		case matID:
-			return std::make_unique<MaterialWrap>(m_materialID);
-		default:
-			return nullptr;	//Requested an unknown index
-	}
-} //MaterialQuantity::getCargo
@@ -1,95 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_MATERIAL_QUANTITY
-#define SPECKLE_RECORD_ELEMENT_MATERIAL_QUANTITY
-
-#include "Active/Serialise/Package/Package.h"
-#include "Active/Setting/Values/Measurement/Units/LengthUnit.h"
-#include "Speckle/Database/Identity/BIMRecordID.h"
-
-namespace speckle::record::element::quants {
-	
-	/*!
-	 Measured material quantities extracted from an element
-	 
-	 This object pairs a material (BuildingMaterial in Archicad) with measurements of surface are ands volume (pssibly more in future).
-	 An element may be constructed of many materials, e.g. the skins of a wall, in which case the quants extracted from the element will
-	 be an array of MaterialQuantity.
-	 */
-	class MaterialQuantity final : public active::serialise::Package {
-	public:
-
-		// MARK: - Types
-		
-			///Unique pointer
-		using Unique = std::unique_ptr<MaterialQuantity>;
-			///Shared pointer
-		using Shared = std::shared_ptr<MaterialQuantity>;
-			///Optional
-		using Option = std::optional<MaterialQuantity>;
-
-		// MARK: - Constructors
-		
-		/*!
-		 Default constructor
-		 */
-		MaterialQuantity() {}
-		/*!
-		 Constructor
-		 @param materialID The ID of the measured material record
-		 @param area The measured surface area (see notes on member variable)
-		 @param volume The measured volume of the material
-		 */
-		MaterialQuantity(const database::BIMRecordID& materialID, double area = 0.0, double volume = 0.0) :
-				m_materialID{materialID}, m_area{area}, m_volume{volume} {}
-
-		// MARK: - Functions (const)
-		
-		/*!
-		 Get the ID of the measured material
-		 @return The material record ID (in the BIM attribute database)
-		 */
-		const database::BIMRecordID& getMaterialID() const { return m_materialID; }
-		/*!
-		 Get the measure surface area of the material
-		 @return The material surface area
-		 */
-		double getArea() const { return m_area; }
-		/*!
-		 Get the measure volume of the material
-		 @return The material volume
-		 */
-		double getVolume() const { return m_volume; }
-
-		// MARK: - Functions (mutating)
-
-		
-		//MARK: - Serialisation
-
-		/*!
-			Fill an inventory with the cargo items
-			@param inventory The inventory to receive the cargo items
-			@return True if items have been added to the inventory
-		*/
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-			Get the specified cargo
-			@param item The inventory item to retrieve
-			@return The requested cargo (nullptr on failure)
-		*/
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		
-	private:
-			///Surface area of the material. Total surface area for basic elements, area of the primary face for 'skinned' elements, e.g. slab top
-		double m_area = 0.0;
-			///Volume of the material
-		double m_volume = 0.0;
-			///The BIM record unit of length measurement
-		std::optional<active::measure::LengthType> m_unit = active::measure::LengthType::metre;
-			///ID of the measured building material
-		database::BIMRecordID m_materialID;
-	};
-	
-	using MaterialQuantityList = std::vector<MaterialQuantity>;
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_MATERIAL_QUANTITY
@@ -1,68 +0,0 @@
-#include "Speckle/Record/Element/Quants/MaterialWrap.h"
-
-#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
-#include "Speckle/Record/Attribute/Material.h"
-
-using namespace active::serialise;
-using namespace speckle::database;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element::quants;
-using namespace speckle::utility;
-
-namespace {
-
-	///Serialisation fields
-	enum FieldIndex {
-		nameID,
-	};
-
-	///Serialisation field IDs
-	static std::array fieldID = {
-		Identity{"name"},
-	};
-	
-}
-
-/*--------------------------------------------------------------------
-	Constructor
-  --------------------------------------------------------------------*/
-MaterialWrap::MaterialWrap(const BIMRecordID& materialID) : m_name{Material{materialID}.getName()} {
-} //MaterialWrap::MaterialWrap
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the cargo items
- 
-	inventory: The inventory to receive the cargo items
- 
-	return: True if items have been added to the inventory
-  --------------------------------------------------------------------*/
-bool MaterialWrap::fillInventory(active::serialise::Inventory& inventory) const {
-	using enum Entry::Type;
-	inventory.merge(Inventory{
-		{
-			{ fieldID[nameID], nameID, element },
-		},
-	}.withType(&typeid(MaterialWrap)));
-	return true;
-} //MaterialWrap::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
- 
-	item: The inventory item to retrieve
- 
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique MaterialWrap::getCargo(const active::serialise::Inventory::Item& item) const {
-	if (item.ownerType != &typeid(MaterialWrap))
-		return nullptr;
-	using namespace active::serialise;
-	switch (item.index) {
-		case nameID:
-			return std::make_unique<ValueWrap<String>>(m_name);
-		default:
-			return nullptr;	//Requested an unknown index
-	}
-} //MaterialWrap::getCargo
@@ -1,47 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_MATERIAL_WRAP
-#define SPECKLE_RECORD_ELEMENT_MATERIAL_WRAP
-
-#include "Active/Serialise/Package/Package.h"
-#include "Speckle/Database/Identity/BIMRecordID.h"
-
-namespace speckle::record::element::quants {
-	
-	/*!
-	 Wrapper for a material exported with a quantity
-	 
-	 NB: This wrapper primarily exports the material name. In future this might be linked to a material proxy, in which case this simple wrapper
-	 will become a MaterialProxy
-	 */
-	class MaterialWrap final : public active::serialise::Package {
-	public:
-
-		// MARK: - Constructors
-		
-		/*!
-		 Constructor
-		 */
-		MaterialWrap(const database::BIMRecordID& materialID);
-		
-		//MARK: - Serialisation
-
-		/*!
-			Fill an inventory with the cargo items
-			@param inventory The inventory to receive the cargo items
-			@return True if items have been added to the inventory
-		*/
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-			Get the specified cargo
-			@param item The inventory item to retrieve
-			@return The requested cargo (nullptr on failure)
-		*/
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		
-	private:
-			///The wrapped material name
-		utility::String m_name;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_MATERIAL_WRAP
@@ -1,86 +0,0 @@
-#include "Speckle/Record/Element/Quants/Surveyor.h"
-
-#include "Active/Utility/Memory.h"
-#include "Speckle/Record/Element/Setting/TypeSetting.h"
-
-using namespace active::math;
-using namespace speckle::database;
-using namespace speckle::record::element::quants;
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Surveyor::Surveyor() {
-#ifdef ARCHICAD
-	active::utility::Memory::erase(m_quantity);
-	active::utility::Memory::erase(m_mask);
-	m_extendedQuantity.elements = &m_quantity;
-	m_extendedQuantity.composites = &m_composites;
-#endif
-} //Surveyor::Surveyor
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
-	
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Surveyor::Surveyor(const Surveyor& source) : m_quantity(source.m_quantity), m_mask(source.m_mask), m_composites{source.m_composites} {
-#ifdef ARCHICAD
-	m_extendedQuantity.elements = &m_quantity;
-	m_extendedQuantity.composites = &m_composites;
-#endif
-} //Surveyor::Surveyor
-
-
-/*--------------------------------------------------------------------
-	Assignment operator
-	
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Surveyor& Surveyor::operator= (const Surveyor& source) {
-	if (this != &source) {
-#ifdef ARCHICAD
-		m_quantity = source.m_quantity;
-		m_mask = source.m_mask;
-		m_composites = source.m_composites;
-		m_extendedQuantity.elements = &m_quantity;
-		m_extendedQuantity.composites = &m_composites;
-#endif
-	}
-	return *this;
-} //Surveyor::operator=
-
-
-/*--------------------------------------------------------------------
-	Measure quantities from a specified element
- 
-	elementLink: Link to the target element
- 
-	return: True if measurements were successfully taken
-  --------------------------------------------------------------------*/
-bool Surveyor::measure(const BIMLink& elementLink) {
-	bool result = false;
-#ifdef ARCHICAD
-	API_QuantityPar quantParams;
-	active::utility::Memory::erase(quantParams);
-	active::utility::Memory::erase(m_quantity);
-	GS::Array<API_ElemPartQuantity> elemPartQuantities;
-	bool isPartQuantities = false;
-	if (auto typeSetting = elementLink.find<TypeSetting>(TypeSetting::ID); typeSetting != nullptr)
-		isPartQuantities = (typeSetting->type == API_MorphID);
-	m_extendedQuantity.elemPartQuantities = isPartQuantities ? &elemPartQuantities : nullptr;
-	quantParams.minOpeningSize = eps;
-	m_composites.Clear();
-	result = (ACAPI_Element_GetQuantities(elementLink, &quantParams, &m_extendedQuantity, &m_mask) == NoError);
-	if (isPartQuantities) {
-		if (result && (elemPartQuantities.GetSize() > 0)) {
-			m_quantity.morph.baseLevel = elemPartQuantities[0].quantity.morph.baseLevel;
-			m_quantity.morph.baseHeight = elemPartQuantities[0].quantity.morph.baseHeight;
-			m_quantity.morph.wholeHeight = elemPartQuantities[0].quantity.morph.wholeHeight;
-		}
-		m_extendedQuantity.elemPartQuantities = nullptr;
-	}
-#endif
-	return result;
-} //Surveyor::measure
@@ -1,97 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_QUANTS_SURVEYOR
-#define SPECKLE_RECORD_ELEMENT_QUANTS_SURVEYOR
-
-#include "Speckle/Database/Identity/BIMLink.h"
-
-#ifdef ARCHICAD
-#include "APIdefs_Elements.h"
-#endif
-
-namespace speckle::record::element::quants {
-	
-	/*!
-	 A utility class to measure element quantities
-	 */
-	class Surveyor {
-	public:
-		/*!
-		 Default constructor
-		 */
-		Surveyor();
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Surveyor(const Surveyor& source);
-		
-		
-		/*!
-		 Assignment operator
-		 @param source The object to copy
-		 @return A reference to this
-		 */
-		Surveyor& operator= (const Surveyor& source);
-
-#ifdef ARCHICAD
-		/*!
-		 Get the quantity measurement values
-		 @return The quantity valuse
-		 */
-		API_ElementQuantity& quantity()	{ return m_quantity; }
-		/*!
-		 Get the mask specifying the values to measure
-		 @return The quantity mask
-		 */
-		API_QuantitiesMask& mask()	{ return m_mask; }
-		/*!
-		 Get the mask specifying the element values to measure
-		 @return The element quantity mask
-		 */
-		API_ElementQuantityMask& elementMask() { return mask().elements; }
-		/*!
-		 Get the mask specifying the composite values to measure
-		 @return The composite quantity mask
-		 */
-		API_CompositeQuantityMask& compositeMask() { return mask().composites; }
-#endif
-		/*!
-		 Measure quantities from a specified element
-		 @param elementLink Link to the target element
-		 @return True if measurements were successfully taken
-		 */
-		bool measure(const database::BIMLink& elementLink);
-		
-#ifdef ARCHICAD
-		/*!
-		 Get the quantity measurement values
-		 @return The quantity valuse
-		 */
-		const API_ElementQuantity& quantity() const	{ return m_quantity; }
-		/*!
-		 Get the mask specifying the values to measure
-		 @return The quantity mask
-		 */
-		const API_QuantitiesMask& mask() const	{ return m_mask; }
-		/*!
-		 Get the mask specifying the composite values to measure
-		 @return The composite quantity mask
-		 */
-		const GS::Array<API_CompositeQuantity>& composites() const { return m_composites; }
-#endif
-		
-	private:
-#ifdef ARCHICAD
-			///Archicad quantity measurement values
-		API_ElementQuantity m_quantity;
-			///Mask specifying the values to measure
-		API_QuantitiesMask m_mask;
-			///Optional additional values to measure, e.g. composite skins, assembly parts etc
-		API_Quantities m_extendedQuantity;
-			///Measurements taken from copmposite skins, e.g. the construction layers of a roof/wall
-		GS::Array<API_CompositeQuantity> m_composites;
-#endif
-	};
-	
-}
-
-#endif //SPECKLE_RECORD_ELEMENT_QUANTS_SURVEYOR
@@ -1,176 +0,0 @@
-#include "Speckle/Record/Element/Roof.h"
-
-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
-
-#ifdef ARCHICAD
-#include <ACAPinc.h>
-#endif
-
-using namespace active::serialise;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
-using namespace speckle::utility;
-
-#include <array>
-#include <memory>
-
-namespace speckle::record::element {
-
-	class Roof::Data {
-	public:
-		friend class Roof;
-
-#ifdef ARCHICAD
-		Data(const API_RoofType& seg) : root{seg} {}
-
-	private:
-		API_RoofType root;
-#endif
-	};
-
-}
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Roof::Roof() {
-} //Roof::Roof
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Constructor
-
-	elemData: Archicad element data
-	tableID: The element table ID (AC database, e.g. floor plan, 3D)
-  --------------------------------------------------------------------*/
-Roof::Roof(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
-	m_data = std::make_unique<Data>(elemData.roof);
-} //Roof::Roof
-#endif
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
-
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Roof::Roof(const Roof& source) : base{ source } {
-	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-} //Roof::Roof
-
-
-/*--------------------------------------------------------------------
-	Move constructor
-
-	source: The object to move
-  --------------------------------------------------------------------*/
-Roof::Roof(Roof&& source) noexcept : base{source} {
-	m_data = std::move(source.m_data);
-} //Roof::Roof
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-Roof::~Roof() {}
-
-
-/*--------------------------------------------------------------------
-	Get the composition of materials in the element
- 
-	return: The material composition (element with ordered material composition should override)
-  --------------------------------------------------------------------*/
-ModelElement::Composition Roof::getComposition() const {
-#ifdef ARCHICAD
-	return convert(m_data->root.shellBase.modelElemStructureType);
-#endif
-} //Roof::getComposition
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> Roof::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.shellBase.buildingMaterial.GenerateHashValue())}};
-#endif
-} //Roof::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure Roof::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().roof.topSurface);
-	BIMMemory::setMask(&surveyor.elementMask().roof.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().roof.topSurface, surveyor.quantity().roof.volume};
-#endif
-} //Roof::getSpatialMeasure
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Get the (immutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-const API_Elem_Head& Roof::getHead() const {
-	return m_data->root.head;
-} //Roof::getHead
-
-
-/*--------------------------------------------------------------------
-	Get the (mutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-API_Elem_Head& Roof::getHead() {
-	return m_data->root.head;
-} //Roof::getHead
-#endif
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
-
-	inventory: The inventory to receive the package items
-
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool Roof::fillInventory(Inventory& inventory) const {
-	using enum Entry::Type;
-		//TODO: Implement other fields as required
-	return base::fillInventory(inventory);
-} //Roof::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
-
-	item: The inventory item to retrieve
-
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique Roof::getCargo(const Inventory::Item& item) const {
-		//TODO: Implement other fields as required
-	return base::getCargo(item);
-} //Roof::getCargo
-
-
-/*--------------------------------------------------------------------
-	Set to the default package content
-  --------------------------------------------------------------------*/
-void Roof::setDefault() {
-	m_data.reset();
-} //Roof::setDefault
@@ -1,125 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_ROOF
-#define SPECKLE_RECORD_ELEMENT_ROOF
-
-#include "Speckle/Record/Element/ModelElement.h"
-#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
-
-namespace speckle::record::element {
-	
-	/*!
-	 BIM roof class
-	 */
-	class Roof : public ModelElement {
-	public:
-
-		// MARK: - Types
-		
-		using base = ModelElement;
-			///Unique pointer
-		using Unique = std::unique_ptr<Roof>;
-			///Shared pointer
-		using Shared = std::shared_ptr<Roof>;
-			///Optional
-		using Option = std::optional<Roof>;
-
-		// MARK: - Constructors
-		
-		using base::base;
-		
-		/*!
-		 Default constructor
-		 */
-		Roof();
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param elemData Archicad element data
-		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
-		 */
-		Roof(const API_Element& elemData, const speckle::utility::Guid& tableID);
-#endif
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Roof(const Roof& source);
-		/*!
-		 Move constructor
-		 @param source The object to move
-		 */
-		Roof(Roof&& source) noexcept;
-		/*!
-		 Destructor
-		 */
-		~Roof();
-
-		/*!
-		 Object cloning
-		 @return A clone of this object
-		 */
-		Roof* clonePtr() const override { return new Roof{*this}; }
-
-
-		// MARK: - Functions (const)
-
-		/*!
-		 Get the composition of materials in the element
-		 @return The material composition (element with ordered material composition should override)
-		 */
-		Composition getComposition() const override;
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
-#ifdef ARCHICAD
-		/*!
-		 Get the (immutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		const API_Elem_Head& getHead() const override;
-#endif
-		
-		// MARK: - Functions (mutating)
-
-#ifdef ARCHICAD
-		/*!
-		 Get the (mutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		API_Elem_Head& getHead() override;
-#endif
-
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		 */
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		 */
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		/*!
-		 Set to the default package content
-		 */
-		void setDefault() override;
-		
-	private:
-		class Data;
-			///The beam data
-		std::unique_ptr<Data> m_data;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_ROOF
@@ -1,30 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_CONVERSION
-#define SPECKLE_RECORD_ELEMENT_CONVERSION
-
-#include "Speckle/Record/Element/ModelElement.h"
-
-#ifdef ARCHICAD
-#include "APIdefs_Elements.h"
-#endif
-
-namespace speckle::record::element {
-
-#ifdef ARCHICAD
-	/*!
-	 Convert an Archicad structure type to an element composition
-	 */
-	inline ModelElement::Composition convert(API_ModelElemStructureType structType) {
-		switch (structType) {
-			case API_CompositeStructure:
-				return ModelElement::Composition::skinned;
-			case API_ProfileStructure:
-				return ModelElement::Composition::profiled;
-			default:
-				return ModelElement::Composition::unordered;
-		}
-	}
-#endif
-	
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_CONVERSION
@@ -1,82 +0,0 @@
-#include "Speckle/Record/Element/Setting/TypeSetting.h"
-
-using namespace speckle::record::element;
-
-/*--------------------------------------------------------------------
-	Equality operator
- 
-	ref: The value to compare
- 
-	return: True if the values are identical
-  --------------------------------------------------------------------*/
-bool TypeSetting::operator==(const BIMIdentity& ref) const {
-	return type == ref;
-} //TypeSetting::operator==
-
-
-/*--------------------------------------------------------------------
-	Equality operator
- 
-	ref: The value to compare
- 
-	return: True if the values are identical
-  --------------------------------------------------------------------*/
-bool TypeSetting::operator==(const Setting& ref) const {
-	if (auto refType = dynamic_cast<const TypeSetting*>(&ref); refType != nullptr)
-		return type == refType->type;
-	return false;
-} //TypeSetting::operator==
-
-
-/*--------------------------------------------------------------------
-	Less-than operator
- 
-	@param ref The value to compare
-	@return True if this is less than ref
-  --------------------------------------------------------------------*/
-bool TypeSetting::operator<(const Setting& ref) const {
-	auto refType = dynamic_cast<const TypeSetting*>(&ref);
-	if (refType == nullptr)
-		return true;
-#ifdef ARCHICAD
-	if (type.typeID < refType->type.typeID)
-		return true;
-	if (type.typeID == refType->type.typeID) {
-		if (type.variationID < refType->type.variationID)
-			return true;
-		if (type.variationID == refType->type.variationID)
-			return (type.classID < refType->type.classID);
-	}
-	return false;
-#endif
-} //TypeSetting::operator==
-
-
-/*--------------------------------------------------------------------
-	Assignment operator
-	@param source The object to copy
-	@return A reference to this
-  --------------------------------------------------------------------*/
-TypeSetting& TypeSetting::operator=(const Setting& source) {
-	if (auto refType = dynamic_cast<const TypeSetting*>(&source); refType != nullptr)
-		type = refType->type;
-	return *this;
-} //TypeSetting::operator==
-
-
-/*--------------------------------------------------------------------
-	///True if the setting is empty
-  --------------------------------------------------------------------*/
-bool TypeSetting::empty() const {
-#ifdef ARCHICAD
-	return type.typeID == API_ZombieElemID;
-#endif
-} //TypeSetting::operator==
-
-
-/*--------------------------------------------------------------------
-	Clear the setting (remove any values)
-  --------------------------------------------------------------------*/
-void TypeSetting::clear() {
-	type = BIMIdentity{};
-} //TypeSetting::clear
@@ -1,113 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_TYPE_SETTING
-#define SPECKLE_RECORD_ELEMENT_TYPE_SETTING
-
-#include "Active/Setting/Setting.h"
-
-#ifdef ARCHICAD
-#include "APIdefs_Elements.h"
-#endif
-
-namespace speckle::record::element {
-
-		///Setting identifying an element type
-	class TypeSetting : public active::setting::Setting {
-	public:
-		
-		// MARK: - Types
-		
-		using base = active::setting::Setting;
-			///BIM platform-specific typoe identifier
-#ifdef ARCHICAD
-		using BIMIdentity = API_ElemType;
-#endif
-			///Unique pointer
-		using Unique = std::unique_ptr<TypeSetting>;
-			///Shared pointer
-		using Shared = std::shared_ptr<TypeSetting>;
-			///Optional
-		using Option = std::optional<TypeSetting>;
-		
-		// MARK: - Constants
-		
-		static const inline active::utility::NameID ID{active::utility::String{"element type"}};
-		
-		// MARK: - Constructors
-		
-		/*!
-		 Constructor
-		 @param identifier A BIM element type identifier
-		 */
-		TypeSetting(const BIMIdentity& identifier = BIMIdentity{}) : base{ID}, type{identifier}	{}
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param head An Archicad element header
-		 */
-		TypeSetting(const API_Elem_Head& head) : base{ID}, type{head.type}	{}
-#endif
-
-		/*!
-		 Clone method
-		 @return A clone of this object
-		 */
-		virtual TypeSetting* clonePtr() const override { return new TypeSetting{*this}; }
-
-		// MARK: - Public variables
-		
-			///Platform-specific type identifier
-		BIMIdentity type;
-		
-		// MARK: Operators
-		
-		/*!
-		 Equality operator
-		 @param ref The value to compare
-		 @return True if the values are identical
-		 */
-		bool operator==(const BIMIdentity& ref) const;
-		/*!
-		 Equality operator
-		 @param ref The value to compare
-		 @return True if the values are identical
-		 */
-		bool operator==(const Setting& ref) const override;
-		/*!
-		 Less-than operator
-		 @param ref The value to compare
-		 @return True if this is less than ref
-		 */
-		bool operator<(const Setting& ref) const override;
-		/*!
-		 Assignment operator
-		 @param source The object to copy
-		 @return A reference to this
-		 */
-		TypeSetting& operator=(const Setting& source) override;
-		/*!
-		 Conversion operator
-		 @return True if the setting is not empty
-		 */
-		operator bool() const { return !empty(); }
-
-		// MARK: - Functions (const)
-		
-		/*!
-		 True if the setting is empty
-		 */
-		bool empty() const override;
-
-		// MARK: Functions (mutating)
-		
-		/*!
-		 Clear the setting (remove any values)
-		 */
-		void clear() override;
-		/*!
-		 Assign a default to the setting
-		 */
-		void setDefault() override { clear(); }
-	};
-	
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_TYPE_SETTING
@@ -1,164 +0,0 @@
-#include "Speckle/Record/Element/Shell.h"
-
-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
-
-#ifdef ARCHICAD
-#include <ACAPinc.h>
-#endif
-
-using namespace active::serialise;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
-using namespace speckle::utility;
-
-#include <array>
-#include <memory>
-
-namespace speckle::record::element {
-
-	class Shell::Data {
-	public:
-		friend class Shell;
-
-#ifdef ARCHICAD
-		Data(const API_ShellType& seg) : root{seg} {}
-
-	private:
-		API_ShellType root;
-#endif
-	};
-
-}
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Shell::Shell() {
-} //Shell::Shell
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Constructor
-
-	elemData: Archicad element data
-	tableID: The element table ID (AC database, e.g. floor plan, 3D)
-  --------------------------------------------------------------------*/
-Shell::Shell(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
-	m_data = std::make_unique<Data>(elemData.shell);
-} //Shell::Shell
-#endif
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
-
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Shell::Shell(const Shell& source) : base{ source } {
-	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-} //Shell::Shell
-
-
-/*--------------------------------------------------------------------
-	Move constructor
-
-	source: The object to move
-  --------------------------------------------------------------------*/
-Shell::Shell(Shell&& source) noexcept : base{source} {
-	m_data = std::move(source.m_data);
-} //Shell::Shell
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-Shell::~Shell() {}
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> Shell::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.shellBase.buildingMaterial.GenerateHashValue())}};
-#endif
-} //Shell::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure Shell::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().shell.referenceSurface);
-	BIMMemory::setMask(&surveyor.elementMask().shell.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().shell.referenceSurface, surveyor.quantity().shell.volume};
-#endif
-} //Shell::getSpatialMeasure
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Get the (immutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-const API_Elem_Head& Shell::getHead() const {
-	return m_data->root.head;
-} //Shell::getHead
-
-
-/*--------------------------------------------------------------------
-	Get the (mutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-API_Elem_Head& Shell::getHead() {
-	return m_data->root.head;
-} //Shell::getHead
-#endif
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
-
-	inventory: The inventory to receive the package items
-
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool Shell::fillInventory(Inventory& inventory) const {
-	using enum Entry::Type;
-		//TODO: Implement other fields as required
-	return base::fillInventory(inventory);
-} //Shell::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
-
-	item: The inventory item to retrieve
-
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique Shell::getCargo(const Inventory::Item& item) const {
-		//TODO: Implement other fields as required
-	return base::getCargo(item);
-} //Shell::getCargo
-
-
-/*--------------------------------------------------------------------
-	Set to the default package content
-  --------------------------------------------------------------------*/
-void Shell::setDefault() {
-	m_data.reset();
-} //Shell::setDefault
@@ -1,120 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_SHELL
-#define SPECKLE_RECORD_ELEMENT_SHELL
-
-#include "Speckle/Record/Element/ModelElement.h"
-#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
-
-namespace speckle::record::element {
-	
-	/*!
-	 BIM shell class
-	 */
-	class Shell : public ModelElement {
-	public:
-
-		// MARK: - Types
-		
-		using base = ModelElement;
-			///Unique pointer
-		using Unique = std::unique_ptr<Shell>;
-			///Shared pointer
-		using Shared = std::shared_ptr<Shell>;
-			///Optional
-		using Option = std::optional<Shell>;
-
-		// MARK: - Constructors
-		
-		using base::base;
-		
-		/*!
-		 Default constructor
-		 */
-		Shell();
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param elemData Archicad element data
-		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
-		 */
-		Shell(const API_Element& elemData, const speckle::utility::Guid& tableID);
-#endif
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Shell(const Shell& source);
-		/*!
-		 Move constructor
-		 @param source The object to move
-		 */
-		Shell(Shell&& source) noexcept;
-		/*!
-		 Destructor
-		 */
-		~Shell();
-
-		/*!
-		 Object cloning
-		 @return A clone of this object
-		 */
-		Shell* clonePtr() const override { return new Shell{*this}; }
-
-
-		// MARK: - Functions (const)
-
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
-#ifdef ARCHICAD
-		/*!
-		 Get the (immutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		const API_Elem_Head& getHead() const override;
-#endif
-		
-		// MARK: - Functions (mutating)
-
-#ifdef ARCHICAD
-		/*!
-		 Get the (mutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		API_Elem_Head& getHead() override;
-#endif
-
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		 */
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		 */
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		/*!
-		 Set to the default package content
-		 */
-		void setDefault() override;
-		
-	private:
-		class Data;
-			///The beam data
-		std::unique_ptr<Data> m_data;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_SHELL
@@ -1,176 +0,0 @@
-#include "Speckle/Record/Element/Slab.h"
-
-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
-
-#ifdef ARCHICAD
-#include <ACAPinc.h>
-#endif
-
-using namespace active::serialise;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
-using namespace speckle::utility;
-
-#include <array>
-#include <memory>
-
-namespace speckle::record::element {
-
-	class Slab::Data {
-	public:
-		friend class Slab;
-
-#ifdef ARCHICAD
-		Data(const API_SlabType& seg) : root{seg} {}
-
-	private:
-		API_SlabType root;
-#endif
-	};
-
-}
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Slab::Slab() {
-} //Slab::Slab
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Constructor
-
-	elemData: Archicad element data
-	tableID: The element table ID (AC database, e.g. floor plan, 3D)
-  --------------------------------------------------------------------*/
-Slab::Slab(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
-	m_data = std::make_unique<Data>(elemData.slab);
-} //Slab::Slab
-#endif
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
-
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Slab::Slab(const Slab& source) : base{ source } {
-	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-} //Slab::Slab
-
-
-/*--------------------------------------------------------------------
-	Move constructor
-
-	source: The object to move
-  --------------------------------------------------------------------*/
-Slab::Slab(Slab&& source) noexcept : base{source} {
-	m_data = std::move(source.m_data);
-} //Slab::Slab
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-Slab::~Slab() {}
-
-
-/*--------------------------------------------------------------------
-	Get the composition of materials in the element
- 
-	return: The material composition (element with ordered material composition should override)
-  --------------------------------------------------------------------*/
-ModelElement::Composition Slab::getComposition() const {
-#ifdef ARCHICAD
-	return convert(m_data->root.modelElemStructureType);
-#endif
-} //Slab::getComposition
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> Slab::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
-#endif
-} //Slab::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure Slab::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().slab.topSurface);
-	BIMMemory::setMask(&surveyor.elementMask().slab.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().slab.topSurface, surveyor.quantity().slab.volume};
-#endif
-} //Slab::getSpatialMeasure
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Get the (immutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-const API_Elem_Head& Slab::getHead() const {
-	return m_data->root.head;
-} //Slab::getHead
-
-
-/*--------------------------------------------------------------------
-	Get the (mutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-API_Elem_Head& Slab::getHead() {
-	return m_data->root.head;
-} //Slab::getHead
-#endif
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
-
-	inventory: The inventory to receive the package items
-
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool Slab::fillInventory(Inventory& inventory) const {
-	using enum Entry::Type;
-		//TODO: Implement other fields as required
-	return base::fillInventory(inventory);
-} //Slab::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
-
-	item: The inventory item to retrieve
-
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique Slab::getCargo(const Inventory::Item& item) const {
-		//TODO: Implement other fields as required
-	return base::getCargo(item);
-} //Slab::getCargo
-
-
-/*--------------------------------------------------------------------
-	Set to the default package content
-  --------------------------------------------------------------------*/
-void Slab::setDefault() {
-	m_data.reset();
-} //Slab::setDefault
@@ -1,125 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_SLAB
-#define SPECKLE_RECORD_ELEMENT_SLAB
-
-#include "Speckle/Record/Element/ModelElement.h"
-#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
-
-namespace speckle::record::element {
-	
-	/*!
-	 BIM slab class
-	 */
-	class Slab : public ModelElement {
-	public:
-
-		// MARK: - Types
-		
-		using base = ModelElement;
-			///Unique pointer
-		using Unique = std::unique_ptr<Slab>;
-			///Shared pointer
-		using Shared = std::shared_ptr<Slab>;
-			///Optional
-		using Option = std::optional<Slab>;
-
-		// MARK: - Constructors
-		
-		using base::base;
-		
-		/*!
-		 Default constructor
-		 */
-		Slab();
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param elemData Archicad element data
-		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
-		 */
-		Slab(const API_Element& elemData, const speckle::utility::Guid& tableID);
-#endif
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Slab(const Slab& source);
-		/*!
-		 Move constructor
-		 @param source The object to move
-		 */
-		Slab(Slab&& source) noexcept;
-		/*!
-		 Destructor
-		 */
-		~Slab();
-
-		/*!
-		 Object cloning
-		 @return A clone of this object
-		 */
-		Slab* clonePtr() const override { return new Slab{*this}; }
-
-
-		// MARK: - Functions (const)
-
-		/*!
-		 Get the composition of materials in the element
-		 @return The material composition (element with ordered material composition should override)
-		 */
-		Composition getComposition() const override;
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
-#ifdef ARCHICAD
-		/*!
-		 Get the (immutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		const API_Elem_Head& getHead() const override;
-#endif
-		
-		// MARK: - Functions (mutating)
-
-#ifdef ARCHICAD
-		/*!
-		 Get the (mutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		API_Elem_Head& getHead() override;
-#endif
-
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		 */
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		 */
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		/*!
-		 Set to the default package content
-		 */
-		void setDefault() override;
-		
-	private:
-		class Data;
-			///The beam data
-		std::unique_ptr<Data> m_data;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_SLAB
@@ -1,176 +0,0 @@
-#include "Speckle/Record/Element/Wall.h"
-
-#include "Speckle/Record/Element/Quants/Surveyor.h"
-#include "Speckle/Record/Element/Setting/Conversion.h"
-#include "Speckle/Utility/BIMMemory.h"
-
-#ifdef ARCHICAD
-#include <ACAPinc.h>
-#endif
-
-using namespace active::serialise;
-using namespace speckle::record::attribute;
-using namespace speckle::record::element;
-using namespace speckle::record::element::quants;
-using namespace speckle::utility;
-
-#include <array>
-#include <memory>
-
-namespace speckle::record::element {
-
-	class Wall::Data {
-	public:
-		friend class Wall;
-
-#ifdef ARCHICAD
-		Data(const API_WallType& seg) : root{seg} {}
-
-	private:
-		API_WallType root;
-#endif
-	};
-
-}
-
-/*--------------------------------------------------------------------
-	Default constructor
-  --------------------------------------------------------------------*/
-Wall::Wall() {
-} //Wall::Wall
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Constructor
-
-	elemData: Archicad element data
-	tableID: The element table ID (AC database, e.g. floor plan, 3D)
-  --------------------------------------------------------------------*/
-Wall::Wall(const API_Element& elemData, const speckle::utility::Guid& tableID) : base{ elemData.header.guid, tableID } {
-	m_data = std::make_unique<Data>(elemData.wall);
-} //Wall::Wall
-#endif
-
-
-/*--------------------------------------------------------------------
-	Copy constructor
-
-	source: The object to copy
-  --------------------------------------------------------------------*/
-Wall::Wall(const Wall& source) : base{ source } {
-	m_data = source.m_data ? std::make_unique<Data>(*source.m_data) : nullptr;
-} //Wall::Wall
-
-
-/*--------------------------------------------------------------------
-	Move constructor
-
-	source: The object to move
-  --------------------------------------------------------------------*/
-Wall::Wall(Wall&& source) noexcept : base{source} {
-	m_data = std::move(source.m_data);
-} //Wall::Wall
-
-
-/*--------------------------------------------------------------------
-	Destructor
-  --------------------------------------------------------------------*/
-Wall::~Wall() {}
-
-
-/*--------------------------------------------------------------------
-	Get the composition of materials in the element
- 
-	return: The material composition (element with ordered material composition should override)
-  --------------------------------------------------------------------*/
-ModelElement::Composition Wall::getComposition() const {
-#ifdef ARCHICAD
-	return convert(m_data->root.modelElemStructureType);
-#endif
-} //Wall::getComposition
-
-
-/*--------------------------------------------------------------------
-	Get the element material (applicable to elements with a single, homogenous material)
- 
-	return: The element material (nullopt if not applicable to the element)
-  --------------------------------------------------------------------*/
-std::optional<Material> Wall::getMaterial() const {
-#ifdef ARCHICAD
-	return Material{Guid{Guid::fromInt(m_data->root.buildingMaterial.GenerateHashValue())}};
-#endif
-} //Wall::getMaterial
-
-
-/*--------------------------------------------------------------------
-	Get a spatial measurement from this element (area/volume, as used for material quantities)
- 
-	return: The element measurement (empty if unavailable)
-  --------------------------------------------------------------------*/
-ModelElement::SpatialMeasure Wall::getSpatialMeasure() const {
-#ifdef ARCHICAD
-	Surveyor surveyor;
-	BIMMemory::setMask(&surveyor.elementMask().wall.surface1);
-	BIMMemory::setMask(&surveyor.elementMask().wall.volume);
-	surveyor.measure(getBIMLink());
-	return SpatialMeasure{surveyor.quantity().wall.surface1, surveyor.quantity().wall.volume};
-#endif
-} //Wall::getSpatialMeasure
-
-
-#ifdef ARCHICAD
-/*--------------------------------------------------------------------
-	Get the (immutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-const API_Elem_Head& Wall::getHead() const {
-	return m_data->root.head;
-} //Wall::getHead
-
-
-/*--------------------------------------------------------------------
-	Get the (mutable) API element header data
-
-	return: The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-  --------------------------------------------------------------------*/
-API_Elem_Head& Wall::getHead() {
-	return m_data->root.head;
-} //Wall::getHead
-#endif
-
-
-/*--------------------------------------------------------------------
-	Fill an inventory with the package items
-
-	inventory: The inventory to receive the package items
-
-	return: True if the package has added items to the inventory
-  --------------------------------------------------------------------*/
-bool Wall::fillInventory(Inventory& inventory) const {
-	using enum Entry::Type;
-		//TODO: Implement other fields as required
-	return base::fillInventory(inventory);
-} //Wall::fillInventory
-
-
-/*--------------------------------------------------------------------
-	Get the specified cargo
-
-	item: The inventory item to retrieve
-
-	return: The requested cargo (nullptr on failure)
-  --------------------------------------------------------------------*/
-Cargo::Unique Wall::getCargo(const Inventory::Item& item) const {
-		//TODO: Implement other fields as required
-	return base::getCargo(item);
-} //Wall::getCargo
-
-
-/*--------------------------------------------------------------------
-	Set to the default package content
-  --------------------------------------------------------------------*/
-void Wall::setDefault() {
-	m_data.reset();
-} //Wall::setDefault
@@ -1,125 +0,0 @@
-#ifndef SPECKLE_RECORD_ELEMENT_WALL
-#define SPECKLE_RECORD_ELEMENT_WALL
-
-#include "Speckle/Record/Element/ModelElement.h"
-#include "Speckle/Record/Element/Interface/Assembly/Segment.h"
-
-namespace speckle::record::element {
-	
-	/*!
-	 BIM wall class
-	 */
-	class Wall : public ModelElement {
-	public:
-
-		// MARK: - Types
-		
-		using base = ModelElement;
-			///Unique pointer
-		using Unique = std::unique_ptr<Wall>;
-			///Shared pointer
-		using Shared = std::shared_ptr<Wall>;
-			///Optional
-		using Option = std::optional<Wall>;
-
-		// MARK: - Constructors
-		
-		using base::base;
-		
-		/*!
-		 Default constructor
-		 */
-		Wall();
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param elemData Archicad element data
-		 @param tableID The element table ID (AC database, e.g. floor plan, 3D)
-		 */
-		Wall(const API_Element& elemData, const speckle::utility::Guid& tableID);
-#endif
-		/*!
-		 Copy constructor
-		 @param source The object to copy
-		 */
-		Wall(const Wall& source);
-		/*!
-		 Move constructor
-		 @param source The object to move
-		 */
-		Wall(Wall&& source) noexcept;
-		/*!
-		 Destructor
-		 */
-		~Wall();
-
-		/*!
-		 Object cloning
-		 @return A clone of this object
-		 */
-		Wall* clonePtr() const override { return new Wall{*this}; }
-
-
-		// MARK: - Functions (const)
-
-		/*!
-		 Get the composition of materials in the element
-		 @return The material composition (element with ordered material composition should override)
-		 */
-		Composition getComposition() const override;
-		/*!
-		 Get the element material (applicable to elements with a single, homogenous material)
-		 @return The element material (nullopt if not applicable to the element)
-		 */
-		std::optional<record::attribute::Material> getMaterial() const override;
-		/*!
-		 Get a spatial measurement from this element (area/volume, as used for material quantities)
-		 @return The element measurement (empty if unavailable)
-		 */
-		SpatialMeasure getSpatialMeasure() const override;
-#ifdef ARCHICAD
-		/*!
-		 Get the (immutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		const API_Elem_Head& getHead() const override;
-#endif
-		
-		// MARK: - Functions (mutating)
-
-#ifdef ARCHICAD
-		/*!
-		 Get the (mutable) API element header data
-		 @return The element header data (only use this data for low-level operations - for normal code, call getters/setters)
-		 */
-		API_Elem_Head& getHead() override;
-#endif
-
-		// MARK: - Serialisation
-		
-		/*!
-		 Fill an inventory with the package items
-		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
-		 */
-		bool fillInventory(active::serialise::Inventory& inventory) const override;
-		/*!
-		 Get the specified cargo
-		 @param item The inventory item to retrieve
-		 @return The requested cargo (nullptr on failure)
-		 */
-		Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
-		/*!
-		 Set to the default package content
-		 */
-		void setDefault() override;
-		
-	private:
-		class Data;
-			///The beam data
-		std::unique_ptr<Data> m_data;
-	};
-
-}
-
-#endif	//SPECKLE_RECORD_ELEMENT_WALL
@@ -29,14 +29,14 @@ namespace speckle::serialise {
 		 @param objectID The object the material is applied to
 		 @return True if the material proxy was added (false typically means the record already exists)
 		 */
-		virtual bool addFinishProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) = 0;
+		virtual bool addMaterialProxy(const speckle::database::BIMIndex& materialIndex, const speckle::database::BIMRecordID& objectID) = 0;
 		/*!
 		 Add a ModelerAPI material to the collection (NB: These are not persistent so need to be captured by this method)
 		 @param finish A finish
 		 @param objectID The object the material is applied to
 		 @return True if the material proxy was added (false typically means the record already exists)
 		 */
-		virtual bool addFinishProxy(const record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) = 0;
+		virtual bool addMaterialProxy(const record::attribute::Finish& finish, const speckle::database::BIMRecordID& objectID) = 0;
 	};
 	
 }
@@ -27,13 +27,13 @@ namespace speckle::serialise {
 		/*!
 		 Fill an inventory with the package items
 		 @param inventory The inventory to receive the package items
-		 @return True if the package has added items to the inventory
+		 @return: True if the package has added items to the inventory
 		 */
 		bool fillInventory(active::serialise::Inventory& inventory) const {
 				//NB: This object only exists to populate the finish collection - it doesn't carry any serialisable content
 			if (management() != nullptr) {
 				if (auto collector = management()->get<FinishCollector>(); collector != nullptr)
-					collector->addFinishProxy(m_material, m_objectID);
+					collector->addMaterialProxy(m_material, m_objectID);
 			}
 			return true;
 		} //DocumentInfo::fillInventory
@@ -21,7 +21,7 @@ namespace active::serialise {
 	 @param source The source string to convert
 	 @return The equivalent colour (nullopt on failure)
 	 */
-	inline std::optional<API_RGBColor> convertToAPI_RGBColor(const utility::String& source) {
+	std::optional<API_RGBColor> convertToAPI_RGBColor(const utility::String& source) {
 		auto intValue = source.toUInt32();
 		if (!intValue)
 			return std::nullopt;
@@ -7,8 +7,6 @@ namespace speckle::utility {
 	
 	/*!
 	 BIM memory functions
-	 
-	 NB: These functions are primarily relevant to C-based BIM APIs that require low-level memory management, e.g. Archicad
 	*/
 	class BIMMemory {
 	public:
@@ -18,11 +16,6 @@ namespace speckle::utility {
 		 @return The allocated pointer size
 		 */
 		static size_t getPtrSize(void* pointer);
-		/*!
-		 Set a mask in a specified byte, i.e. fill with 1s
-		 @param byte A pointer to the target byte
-		 */
-		static void setMask(void* byte) { *(reinterpret_cast<unsigned char*>(byte)) = 0xFF; }
 	};
 	
 }
@@ -20,29 +20,6 @@
 		21384BC52CD24AB200D4602B /* ElementSubscriber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384BC12CD24AB200D4602B /* ElementSubscriber.cpp */; };
 		21384BC62CD24AB200D4602B /* ElementSubscriber.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BC42CD24AB200D4602B /* ElementSubscriber.h */; };
 		21384BC82CD24ADC00D4602B /* ElementEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BC72CD24ADC00D4602B /* ElementEvent.h */; };
-		21384BE82CD3DD6200D4602B /* MaterialQuantity.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384BE32CD3DD6200D4602B /* MaterialQuantity.cpp */; };
-		21384BE92CD3DD6200D4602B /* MaterialQuantity.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BE42CD3DD6200D4602B /* MaterialQuantity.h */; };
-		21384BEC2CD3EBE200D4602B /* Material.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BEA2CD3EBE200D4602B /* Material.h */; };
-		21384BED2CD3EBE200D4602B /* Material.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384BEB2CD3EBE200D4602B /* Material.cpp */; };
-		21384BF02CD3F3A500D4602B /* MaterialWrap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384BEE2CD3F3A500D4602B /* MaterialWrap.cpp */; };
-		21384BF12CD3F3A500D4602B /* MaterialWrap.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BEF2CD3F3A500D4602B /* MaterialWrap.h */; };
-		21384BF42CD4D65700D4602B /* Surveyor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384BF22CD4D65700D4602B /* Surveyor.cpp */; };
-		21384BF52CD4D65700D4602B /* Surveyor.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BF32CD4D65700D4602B /* Surveyor.h */; };
-		21384BF82CD50CD400D4602B /* TypeSetting.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BF62CD50CD400D4602B /* TypeSetting.h */; };
-		21384BFA2CD51B6F00D4602B /* TypeSetting.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384BF92CD51B6F00D4602B /* TypeSetting.cpp */; };
-		21384BFC2CD52C7500D4602B /* Conversion.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BFB2CD52C7500D4602B /* Conversion.h */; };
-		21384BFF2CD558D100D4602B /* Slab.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384BFD2CD558D000D4602B /* Slab.cpp */; };
-		21384C002CD558D100D4602B /* Slab.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384BFE2CD558D000D4602B /* Slab.h */; };
-		21384C032CD57CA500D4602B /* Wall.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384C012CD57CA500D4602B /* Wall.cpp */; };
-		21384C042CD57CA500D4602B /* Wall.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384C022CD57CA500D4602B /* Wall.h */; };
-		21384C182CD585A600D4602B /* Roof.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384C162CD585A600D4602B /* Roof.cpp */; };
-		21384C192CD585A600D4602B /* Roof.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384C172CD585A600D4602B /* Roof.h */; };
-		21384C1C2CD586D800D4602B /* Morph.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384C1A2CD586D800D4602B /* Morph.cpp */; };
-		21384C1D2CD586D800D4602B /* Morph.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384C1B2CD586D800D4602B /* Morph.h */; };
-		21384C202CD5880400D4602B /* Shell.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384C1E2CD5880400D4602B /* Shell.h */; };
-		21384C212CD5880400D4602B /* Shell.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384C1F2CD5880400D4602B /* Shell.cpp */; };
-		21384C242CD59B4100D4602B /* MeshElem.h in Headers */ = {isa = PBXBuildFile; fileRef = 21384C222CD59B4100D4602B /* MeshElem.h */; };
-		21384C252CD59B4100D4602B /* MeshElem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21384C232CD59B4100D4602B /* MeshElem.cpp */; };
 		215F08552C99DA8D00CD343B /* Project.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08512C99DA8D00CD343B /* Project.cpp */; };
 		215F08562C99DA8D00CD343B /* Project.h in Headers */ = {isa = PBXBuildFile; fileRef = 215F08542C99DA8D00CD343B /* Project.h */; };
 		215F08662C9B006800CD343B /* ProjectEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08652C9B006700CD343B /* ProjectEvent.cpp */; };
@@ -229,29 +206,6 @@
 		21384BC12CD24AB200D4602B /* ElementSubscriber.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ElementSubscriber.cpp; sourceTree = "<group>"; };
 		21384BC42CD24AB200D4602B /* ElementSubscriber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ElementSubscriber.h; sourceTree = "<group>"; };
 		21384BC72CD24ADC00D4602B /* ElementEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ElementEvent.h; sourceTree = "<group>"; };
-		21384BE32CD3DD6200D4602B /* MaterialQuantity.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MaterialQuantity.cpp; sourceTree = "<group>"; };
-		21384BE42CD3DD6200D4602B /* MaterialQuantity.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MaterialQuantity.h; sourceTree = "<group>"; };
-		21384BEA2CD3EBE200D4602B /* Material.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Material.h; sourceTree = "<group>"; };
-		21384BEB2CD3EBE200D4602B /* Material.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Material.cpp; sourceTree = "<group>"; };
-		21384BEE2CD3F3A500D4602B /* MaterialWrap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MaterialWrap.cpp; sourceTree = "<group>"; };
-		21384BEF2CD3F3A500D4602B /* MaterialWrap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MaterialWrap.h; sourceTree = "<group>"; };
-		21384BF22CD4D65700D4602B /* Surveyor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Surveyor.cpp; sourceTree = "<group>"; };
-		21384BF32CD4D65700D4602B /* Surveyor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Surveyor.h; sourceTree = "<group>"; };
-		21384BF62CD50CD400D4602B /* TypeSetting.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TypeSetting.h; sourceTree = "<group>"; };
-		21384BF92CD51B6F00D4602B /* TypeSetting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TypeSetting.cpp; sourceTree = "<group>"; };
-		21384BFB2CD52C7500D4602B /* Conversion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Conversion.h; sourceTree = "<group>"; };
-		21384BFD2CD558D000D4602B /* Slab.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Slab.cpp; sourceTree = "<group>"; };
-		21384BFE2CD558D000D4602B /* Slab.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Slab.h; sourceTree = "<group>"; };
-		21384C012CD57CA500D4602B /* Wall.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Wall.cpp; sourceTree = "<group>"; };
-		21384C022CD57CA500D4602B /* Wall.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Wall.h; sourceTree = "<group>"; };
-		21384C162CD585A600D4602B /* Roof.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Roof.cpp; sourceTree = "<group>"; };
-		21384C172CD585A600D4602B /* Roof.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Roof.h; sourceTree = "<group>"; };
-		21384C1A2CD586D800D4602B /* Morph.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Morph.cpp; sourceTree = "<group>"; };
-		21384C1B2CD586D800D4602B /* Morph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Morph.h; sourceTree = "<group>"; };
-		21384C1E2CD5880400D4602B /* Shell.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Shell.h; sourceTree = "<group>"; };
-		21384C1F2CD5880400D4602B /* Shell.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Shell.cpp; sourceTree = "<group>"; };
-		21384C222CD59B4100D4602B /* MeshElem.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MeshElem.h; sourceTree = "<group>"; };
-		21384C232CD59B4100D4602B /* MeshElem.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MeshElem.cpp; sourceTree = "<group>"; };
 		214EA4C52BA374FD008E5358 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
 		214EA4C62BA3762D008E5358 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = SOURCE_ROOT; };
 		215F08512C99DA8D00CD343B /* Project.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Project.cpp; sourceTree = "<group>"; };
@@ -303,7 +257,6 @@
 		2196F3022CB57E7F00450DFC /* Storey.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Storey.h; sourceTree = "<group>"; };
 		2196F3032CB57E7F00450DFC /* Storey.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Storey.cpp; sourceTree = "<group>"; };
 		219712682BE7E2D500D9EF7E /* Serialisation.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = Serialisation.md; sourceTree = "<group>"; };
-		2199BB5F2CDB761B00A4BEEC /* ElementStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ElementStorage.h; sourceTree = "<group>"; };
 		21A0FB9F2CB880690023F24E /* FinishCollector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FinishCollector.h; sourceTree = "<group>"; };
 		21A0FBA92CB9324A0023F24E /* FinishProxy.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FinishProxy.h; sourceTree = "<group>"; };
 		21A0FBB42CBA5E380023F24E /* Str256.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Str256.h; sourceTree = "<group>"; };
@@ -502,29 +455,6 @@
 			name = Products;
 			sourceTree = "<group>";
 		};
-		21384BE52CD3DD6200D4602B /* Quants */ = {
-			isa = PBXGroup;
-			children = (
-				21384BE32CD3DD6200D4602B /* MaterialQuantity.cpp */,
-				21384BE42CD3DD6200D4602B /* MaterialQuantity.h */,
-				21384BEE2CD3F3A500D4602B /* MaterialWrap.cpp */,
-				21384BEF2CD3F3A500D4602B /* MaterialWrap.h */,
-				21384BF22CD4D65700D4602B /* Surveyor.cpp */,
-				21384BF32CD4D65700D4602B /* Surveyor.h */,
-			);
-			path = Quants;
-			sourceTree = "<group>";
-		};
-		21384BF72CD50CD400D4602B /* Setting */ = {
-			isa = PBXGroup;
-			children = (
-				21384BFB2CD52C7500D4602B /* Conversion.h */,
-				21384BF92CD51B6F00D4602B /* TypeSetting.cpp */,
-				21384BF62CD50CD400D4602B /* TypeSetting.h */,
-			);
-			path = Setting;
-			sourceTree = "<group>";
-		};
 		215F08612C9AE3D200CD343B /* RINT */ = {
 			isa = PBXGroup;
 			children = (
@@ -552,25 +482,11 @@
 				21A890CB2CC1B87B0087E732 /* GenericDrawingElement.h */,
 				21A890CD2CC1B87C0087E732 /* GenericModelElement.cpp */,
 				21A890CC2CC1B87B0087E732 /* GenericModelElement.h */,
+				21A0FC0C2CBE92F10023F24E /* ModelElement.cpp */,
+				21A0FC0D2CBE92F10023F24E /* ModelElement.h */,
 				21A0FBE72CBD6B1A0023F24E /* Interface */,
 				21A0FBF32CBD6B700023F24E /* Memo.cpp */,
 				21A0FBF22CBD6B700023F24E /* Memo.h */,
-				21384C232CD59B4100D4602B /* MeshElem.cpp */,
-				21384C222CD59B4100D4602B /* MeshElem.h */,
-				21A0FC0C2CBE92F10023F24E /* ModelElement.cpp */,
-				21A0FC0D2CBE92F10023F24E /* ModelElement.h */,
-				21384C1A2CD586D800D4602B /* Morph.cpp */,
-				21384C1B2CD586D800D4602B /* Morph.h */,
-				21384BE52CD3DD6200D4602B /* Quants */,
-				21384C162CD585A600D4602B /* Roof.cpp */,
-				21384C172CD585A600D4602B /* Roof.h */,
-				21384BF72CD50CD400D4602B /* Setting */,
-				21384C1F2CD5880400D4602B /* Shell.cpp */,
-				21384C1E2CD5880400D4602B /* Shell.h */,
-				21384BFD2CD558D000D4602B /* Slab.cpp */,
-				21384BFE2CD558D000D4602B /* Slab.h */,
-				21384C012CD57CA500D4602B /* Wall.cpp */,
-				21384C022CD57CA500D4602B /* Wall.h */,
 			);
 			path = Element;
 			sourceTree = "<group>";
@@ -693,8 +609,6 @@
 				2196F2EE2CB4823C00450DFC /* Attribute.h */,
 				2196F2F32CB483D600450DFC /* Finish.cpp */,
 				2196F2F22CB483D600450DFC /* Finish.h */,
-				21384BEB2CD3EBE200D4602B /* Material.cpp */,
-				21384BEA2CD3EBE200D4602B /* Material.h */,
 				2196F3032CB57E7F00450DFC /* Storey.cpp */,
 				2196F3022CB57E7F00450DFC /* Storey.h */,
 			);
@@ -709,14 +623,6 @@
 			path = SpeckleLibDoctest;
 			sourceTree = "<group>";
 		};
-		2199BB602CDB761B00A4BEEC /* Element */ = {
-			isa = PBXGroup;
-			children = (
-				2199BB5F2CDB761B00A4BEEC /* ElementStorage.h */,
-			);
-			path = Element;
-			sourceTree = "<group>";
-		};
 		21A0FBA02CB880690023F24E /* Collection */ = {
 			isa = PBXGroup;
 			children = (
@@ -895,7 +801,6 @@
 		21D0BDB02C8F8AB60077E104 /* Storage */ = {
 			isa = PBXGroup;
 			children = (
-				2199BB602CDB761B00A4BEEC /* Element */,
 				215F088A2CA195EC00CD343B /* ArchicadDBase */,
 				21D0BDAF2C8F8AB60077E104 /* DocumentStore */,
 			);
@@ -1032,7 +937,6 @@
 				21A0FBF42CBD6B700023F24E /* Memo.h in Headers */,
 				215F088C2CA195EC00CD343B /* ArchicadDBaseCore.h in Headers */,
 				21AE19AD2CC8F214004DBCFC /* SegmentedBeam.h in Headers */,
-				21384C1D2CD586D800D4602B /* Morph.h in Headers */,
 				21D0BDE72C943D3F0077E104 /* RecordID.h in Headers */,
 				21D0BD212C86F0280077E104 /* AccountDatabase.h in Headers */,
 				21A0FBB52CBA5E380023F24E /* Str256.h in Headers */,
@@ -1045,7 +949,6 @@
 				21B67D0D2C7E0E8D00FD64FC /* ErrorReport.h in Headers */,
 				21AE19A92CC8F1F8004DBCFC /* Beam.h in Headers */,
 				215F08962CA19AF800CD343B /* BIMElementDatabase.h in Headers */,
-				21384BEC2CD3EBE200D4602B /* Material.h in Headers */,
 				2196F2F12CB4823C00450DFC /* Attribute.h in Headers */,
 				21D0BD332C86FE090077E104 /* Link.h in Headers */,
 				21AE19612CC2D358004DBCFC /* Setting.h in Headers */,
@@ -1053,22 +956,18 @@
 				21A890C92CC1B5FF0087E732 /* DrawingElement.h in Headers */,
 				21D0BD562C890B1C0077E104 /* ServerMigration.h in Headers */,
 				210CC88F2C81A98500610F58 /* Guid64.h in Headers */,
-				21384C242CD59B4100D4602B /* MeshElem.h in Headers */,
 				21AEF9DD2CAAA4EA000B8681 /* DetachedObjectStore.h in Headers */,
 				21A0FBF12CBD6B1A0023F24E /* Column.h in Headers */,
 				21AE19662CC2F702004DBCFC /* BIMPropertyDatabase.h in Headers */,
 				21A0FC072CBE59A80023F24E /* Path.h in Headers */,
 				21A0FBA42CB880690023F24E /* FinishCollector.h in Headers */,
-				21384C192CD585A600D4602B /* Roof.h in Headers */,
 				21AE19802CC7D265004DBCFC /* PropertiedWrapper.h in Headers */,
 				21A0FC0B2CBE5E220023F24E /* Segment.h in Headers */,
 				215F088D2CA195EC00CD343B /* ArchicadElementDBaseEngine.h in Headers */,
 				21384BC82CD24ADC00D4602B /* ElementEvent.h in Headers */,
-				21384C202CD5880400D4602B /* Shell.h in Headers */,
 				2196F2F42CB483D600450DFC /* Finish.h in Headers */,
 				21A0FBED2CBD6B1A0023F24E /* Part.h in Headers */,
 				21B67D002C7CE15100FD64FC /* Exception.h in Headers */,
-				21384BF52CD4D65700D4602B /* Surveyor.h in Headers */,
 				21A0FBEB2CBD6B1A0023F24E /* ColumnSegment.h in Headers */,
 				21D0BD2C2C86FC350077E104 /* Record.h in Headers */,
 				21D0BDB42C8F8AB60077E104 /* DocumentStoreCore.h in Headers */,
@@ -1081,26 +980,20 @@
 				21AE198F2CC80541004DBCFC /* ArchicadGroupDBaseEngine.h in Headers */,
 				21D0BD4D2C8901A00077E104 /* ServerInfo.h in Headers */,
 				2196F3042CB57E8000450DFC /* Storey.h in Headers */,
-				21384C042CD57CA500D4602B /* Wall.h in Headers */,
 				21AE196F2CC64D37004DBCFC /* Classified.h in Headers */,
 				21AE19522CC273F1004DBCFC /* Property.h in Headers */,
 				21A0FBF92CBDB9A70023F24E /* BIMMemory.h in Headers */,
 				21AE19AA2CC8F1F8004DBCFC /* BeamSegment.h in Headers */,
-				21384BF12CD3F3A500D4602B /* MaterialWrap.h in Headers */,
 				21AE19942CC82866004DBCFC /* BIMGroupDatabase.h in Headers */,
 				21AE19542CC273F1004DBCFC /* Template.h in Headers */,
 				21A0FBBC2CBBC04C0023F24E /* ArchicadRGB.h in Headers */,
-				21384BFC2CD52C7500D4602B /* Conversion.h in Headers */,
 				21AE19842CC7D517004DBCFC /* PropertyWrapper.h in Headers */,
 				21A0FC052CBE59A80023F24E /* SegmentedColumn.h in Headers */,
 				21A0FC0F2CBE92F10023F24E /* ModelElement.h in Headers */,
 				21D0BDB52C8F8AB60077E104 /* DocumentStoreEngine.h in Headers */,
-				21384BE92CD3DD6200D4602B /* MaterialQuantity.h in Headers */,
 				21A890D02CC1B87C0087E732 /* GenericModelElement.h in Headers */,
-				21384C002CD558D100D4602B /* Slab.h in Headers */,
 				21A890C52CC171D80087E732 /* ArchicadPropertyDBaseEngine.h in Headers */,
 				21384BAB2CCDA9B400D4602B /* Host.h in Headers */,
-				21384BF82CD50CD400D4602B /* TypeSetting.h in Headers */,
 				21D0BDC52C9241940077E104 /* ProjectSubscriber.h in Headers */,
 				21AE196A2CC57832004DBCFC /* Propertied.h in Headers */,
 				2196F2EC2CB4816B00450DFC /* ArchicadAttributeDBaseEngine.h in Headers */,
@@ -1240,7 +1133,6 @@
 				215F088B2CA195EC00CD343B /* ArchicadDBaseCore.cpp in Sources */,
 				2193517B2C624FC100E5A69C /* MenuSubscriber.cpp in Sources */,
 				2196F2F02CB4823C00450DFC /* Attribute.cpp in Sources */,
-				21384C032CD57CA500D4602B /* Wall.cpp in Sources */,
 				21F69F612C6D0286008B6A06 /* GetBindingsMethodNames.cpp in Sources */,
 				215F08662C9B006800CD343B /* ProjectEvent.cpp in Sources */,
 				21AE19932CC82866004DBCFC /* BIMGroupDatabase.cpp in Sources */,
@@ -1255,8 +1147,6 @@
 				2196F2F82CB51ED400450DFC /* BIMAttributeDatabase.cpp in Sources */,
 				21D0BD4E2C8901A00077E104 /* ServerInfo.cpp in Sources */,
 				21AE19512CC273F1004DBCFC /* Property.cpp in Sources */,
-				21384BED2CD3EBE200D4602B /* Material.cpp in Sources */,
-				21384C252CD59B4100D4602B /* MeshElem.cpp in Sources */,
 				21B67D0E2C7E0E8D00FD64FC /* ErrorReport.cpp in Sources */,
 				21AE19902CC80541004DBCFC /* ArchicadGroupDBaseEngine.cpp in Sources */,
 				21AE19692CC57832004DBCFC /* Propertied.cpp in Sources */,
@@ -1264,16 +1154,13 @@
 				2196F3052CB57E8000450DFC /* Storey.cpp in Sources */,
 				219245FE2CA2CC4300CF5703 /* BIMRecord.cpp in Sources */,
 				21AE19572CC27DB3004DBCFC /* Value.cpp in Sources */,
-				21384BFF2CD558D100D4602B /* Slab.cpp in Sources */,
 				21AE19A82CC8F1F8004DBCFC /* BeamSegment.cpp in Sources */,
 				21AEF9BE2CA6FDA4000B8681 /* DetachedWrap.cpp in Sources */,
 				21A0FC062CBE59A80023F24E /* Path.cpp in Sources */,
 				2196F2F52CB483D600450DFC /* Finish.cpp in Sources */,
 				21A0FBEA2CBD6B1A0023F24E /* ColumnSegment.cpp in Sources */,
-				21384BFA2CD51B6F00D4602B /* TypeSetting.cpp in Sources */,
 				2193519B2C6278D900E5A69C /* SelectionSubscriber.cpp in Sources */,
 				21D0BD2B2C86FC350077E104 /* Record.cpp in Sources */,
-				21384BF02CD3F3A500D4602B /* MaterialWrap.cpp in Sources */,
 				219246042CA2CE2700CF5703 /* BIMLink.cpp in Sources */,
 				21A890CE2CC1B87C0087E732 /* GenericDrawingElement.cpp in Sources */,
 				215F08952CA19AF800CD343B /* BIMElementDatabase.cpp in Sources */,
@@ -1288,21 +1175,17 @@
 				21D0BD592C8910400077E104 /* UserInfo.cpp in Sources */,
 				210CC8902C81A98500610F58 /* Guid64.cpp in Sources */,
 				21D0BDC42C9241940077E104 /* ProjectSubscriber.cpp in Sources */,
-				21384BE82CD3DD6200D4602B /* MaterialQuantity.cpp in Sources */,
 				21AE19622CC2D358004DBCFC /* Setting.cpp in Sources */,
 				219351B32C62CC1A00E5A69C /* String.cpp in Sources */,
 				219351B12C62CC1A00E5A69C /* Guid.cpp in Sources */,
 				21F69F512C6CCC25008B6A06 /* BrowserBridge.cpp in Sources */,
 				21A0FC112CBEE5C30023F24E /* Part.cpp in Sources */,
-				21384C212CD5880400D4602B /* Shell.cpp in Sources */,
 				21A890D12CC1B87C0087E732 /* GenericModelElement.cpp in Sources */,
 				21AEF9BC2CA6DF84000B8681 /* DetachmentManager.cpp in Sources */,
 				215F08552C99DA8D00CD343B /* Project.cpp in Sources */,
 				21AE19882CC7FF5F004DBCFC /* Group.cpp in Sources */,
-				21384C182CD585A600D4602B /* Roof.cpp in Sources */,
 				21F69F3B2C6B880C008B6A06 /* JSBaseTransport.cpp in Sources */,
 				21384BC52CD24AB200D4602B /* ElementSubscriber.cpp in Sources */,
-				21384BF42CD4D65700D4602B /* Surveyor.cpp in Sources */,
 				2196F2EB2CB4816B00450DFC /* ArchicadAttributeDBaseEngine.cpp in Sources */,
 				21AE19532CC273F1004DBCFC /* Template.cpp in Sources */,
 				21384BAC2CCDA9B400D4602B /* Host.cpp in Sources */,
@@ -1313,7 +1196,6 @@
 				21F69F962C71087A008B6A06 /* Account.cpp in Sources */,
 				21A0FBF82CBDB9A70023F24E /* BIMMemory.cpp in Sources */,
 				21A0FBF52CBD6B700023F24E /* Memo.cpp in Sources */,
-				21384C1C2CD586D800D4602B /* Morph.cpp in Sources */,
 				21AEF9BA2CA606B5000B8681 /* DetachedReference.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -38,7 +38,6 @@
    <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\Property\ArchicadPropertyDBaseEngine.h" />
    <ClInclude Include="Speckle\Database\Storage\DocumentStore\DocumentStoreCore.h" />
    <ClInclude Include="Speckle\Database\Storage\DocumentStore\DocumentStoreEngine.h" />
-    <ClInclude Include="Speckle\Database\Storage\Element\ElementStorage.h" />
    <ClInclude Include="Speckle\Environment\Addon.h" />
    <ClInclude Include="Speckle\Environment\Host.h" />
    <ClInclude Include="Speckle\Environment\Platform.h" />
@@ -73,7 +72,6 @@
    <ClInclude Include="Speckle\Primitive\Mesh\Mesh.h" />
    <ClInclude Include="Speckle\Record\Attribute\Attribute.h" />
    <ClInclude Include="Speckle\Record\Attribute\Finish.h" />
-    <ClInclude Include="Speckle\Record\Attribute\Material.h" />
    <ClInclude Include="Speckle\Record\Attribute\Storey.h" />
    <ClInclude Include="Speckle\Record\Classification\Classified.h" />
    <ClInclude Include="Speckle\Record\Credentials\Account.h" />
@@ -94,18 +92,7 @@
    <ClInclude Include="Speckle\Record\Element\Interface\SegmentedBeam.h" />
    <ClInclude Include="Speckle\Record\Element\Interface\SegmentedColumn.h" />
    <ClInclude Include="Speckle\Record\Element\Memo.h" />
-    <ClInclude Include="Speckle\Record\Element\MeshElem.h" />
    <ClInclude Include="Speckle\Record\Element\ModelElement.h" />
-    <ClInclude Include="Speckle\Record\Element\Morph.h" />
-    <ClInclude Include="Speckle\Record\Element\Quants\MaterialQuantity.h" />
-    <ClInclude Include="Speckle\Record\Element\Quants\MaterialWrap.h" />
-    <ClInclude Include="Speckle\Record\Element\Quants\Surveyor.h" />
-    <ClInclude Include="Speckle\Record\Element\Roof.h" />
-    <ClInclude Include="Speckle\Record\Element\Setting\Conversion.h" />
-    <ClInclude Include="Speckle\Record\Element\Setting\TypeSetting.h" />
-    <ClInclude Include="Speckle\Record\Element\Shell.h" />
-    <ClInclude Include="Speckle\Record\Element\Slab.h" />
-    <ClInclude Include="Speckle\Record\Element\Wall.h" />
    <ClInclude Include="Speckle\Record\Property\Group.h" />
    <ClInclude Include="Speckle\Record\Property\Propertied.h" />
    <ClInclude Include="Speckle\Record\Property\Property.h" />
@@ -169,7 +156,6 @@
    <ClCompile Include="Speckle\Primitive\Mesh\Mesh.cpp" />
    <ClCompile Include="Speckle\Record\Attribute\Attribute.cpp" />
    <ClCompile Include="Speckle\Record\Attribute\Finish.cpp" />
-    <ClCompile Include="Speckle\Record\Attribute\Material.cpp" />
    <ClCompile Include="Speckle\Record\Attribute\Storey.cpp" />
    <ClCompile Include="Speckle\Record\Classification\Classified.cpp" />
    <ClCompile Include="Speckle\Record\Credentials\Account.cpp" />
@@ -190,17 +176,7 @@
    <ClCompile Include="Speckle\Record\Element\Interface\SegmentedBeam.cpp" />
    <ClCompile Include="Speckle\Record\Element\Interface\SegmentedColumn.cpp" />
    <ClCompile Include="Speckle\Record\Element\Memo.cpp" />
-    <ClCompile Include="Speckle\Record\Element\MeshElem.cpp" />
    <ClCompile Include="Speckle\Record\Element\ModelElement.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Morph.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Quants\MaterialQuantity.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Quants\MaterialWrap.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Quants\Surveyor.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Roof.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Setting\TypeSetting.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Shell.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Slab.cpp" />
-    <ClCompile Include="Speckle\Record\Element\Wall.cpp" />
    <ClCompile Include="Speckle\Record\Property\Group.cpp" />
    <ClCompile Include="Speckle\Record\Property\Propertied.cpp" />
    <ClCompile Include="Speckle\Record\Property\Property.cpp" />
@@ -349,7 +325,7 @@
      <WarningLevel>Level3</WarningLevel>
      <SDLCheck>
      </SDLCheck>
-      <PreprocessorDefinitions>DEBUG;WINDOWS;ARCHICAD;ACExtension;_SILENCE_CXX20_IS_POD_DEPRECATION_WARNING;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>DEBUG;WINDOWS;ARCHICAD;ACExtension;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>false</ConformanceMode>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <PrecompiledHeaderFile>
@@ -389,7 +365,7 @@
      <FunctionLevelLinking>false</FunctionLevelLinking>
      <IntrinsicFunctions>true</IntrinsicFunctions>
      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WINDOWS;ARCHICAD;ACExtension;_SILENCE_CXX20_IS_POD_DEPRECATION_WARNING;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WINDOWS;ARCHICAD;ACExtension;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <ConformanceMode>true</ConformanceMode>
      <PrecompiledHeader>NotUsing</PrecompiledHeader>
      <PrecompiledHeaderFile>
@@ -116,15 +116,6 @@
    <Filter Include="Speckle\Database\Storage\ArchicadDBase\Property">
      <UniqueIdentifier>{f9b0554b-d0a5-40c0-ac20-22032dc8f30c}</UniqueIdentifier>
    </Filter>
-    <Filter Include="Speckle\Record\Element\Setting">
-      <UniqueIdentifier>{453f429b-4ca8-400b-b60c-df80c6d0ec5f}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Speckle\Record\Element\Quants">
-      <UniqueIdentifier>{c05efdee-e236-4db7-9338-a982c9cc673f}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Speckle\Database\Storage\Element">
-      <UniqueIdentifier>{f4cd84a1-f6c1-449f-98cd-d902cc3d9e8c}</UniqueIdentifier>
-    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Speckle\Environment\Addon.h">
@@ -430,45 +421,6 @@
    <ClInclude Include="Speckle\Event\Subscriber\ElementSubscriber.h">
      <Filter>Speckle\Event\Subscriber</Filter>
    </ClInclude>
-    <ClInclude Include="Speckle\Record\Attribute\Material.h">
-      <Filter>Speckle\Record\Attribute</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Quants\MaterialQuantity.h">
-      <Filter>Speckle\Record\Element\Quants</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Quants\MaterialWrap.h">
-      <Filter>Speckle\Record\Element\Quants</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Quants\Surveyor.h">
-      <Filter>Speckle\Record\Element\Quants</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Setting\Conversion.h">
-      <Filter>Speckle\Record\Element\Setting</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Setting\TypeSetting.h">
-      <Filter>Speckle\Record\Element\Setting</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\MeshElem.h">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Morph.h">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Roof.h">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Shell.h">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Slab.h">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Record\Element\Wall.h">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClInclude>
-    <ClInclude Include="Speckle\Database\Storage\Element\ElementStorage.h">
-      <Filter>Speckle\Database\Storage\Element</Filter>
-    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="Speckle\Environment\Addon.cpp">
@@ -690,39 +642,6 @@
    <ClCompile Include="Speckle\Event\Subscriber\ElementSubscriber.cpp">
      <Filter>Speckle\Event\Subscriber</Filter>
    </ClCompile>
-    <ClCompile Include="Speckle\Record\Attribute\Material.cpp">
-      <Filter>Speckle\Record\Attribute</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Quants\MaterialQuantity.cpp">
-      <Filter>Speckle\Record\Element\Quants</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Quants\MaterialWrap.cpp">
-      <Filter>Speckle\Record\Element\Quants</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Quants\Surveyor.cpp">
-      <Filter>Speckle\Record\Element\Quants</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Setting\TypeSetting.cpp">
-      <Filter>Speckle\Record\Element\Setting</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\MeshElem.cpp">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Morph.cpp">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Roof.cpp">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Shell.cpp">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Slab.cpp">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClCompile>
-    <ClCompile Include="Speckle\Record\Element\Wall.cpp">
-      <Filter>Speckle\Record\Element</Filter>
-    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <Text Include="Speckle\CMakeLists.txt">
Author	SHA1	Message	Date
David Kekesi	e9d669c4dd	do not merge - hack for exporting gridlines - each edge is a separate polyline	2024-10-31 18:15:08 +01:00
David Kekesi	e4e31314d6	WIP	2024-10-31 13:09:35 +01:00