Batch sample

Updated with GetSendSettings
Added GetSendSettings binding
2024-10-02 18:17:13 +03:00 · 2024-10-02 12:54:48 +01:00 · 2024-10-02 10:09:28 +01:00 · 2024-10-02 09:30:53 +01:00 · 2024-10-01 18:58:50 +01:00 · 2024-10-01 18:24:33 +01:00
70 changed files with 3383 additions and 54 deletions
@@ -111,7 +111,12 @@
    <ClCompile Include="Connector\Interface\Browser\Bridge\Config\GetConfig.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Config\GetIsDevMode.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Config\UpdateConfig.cpp" />
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\ConversionResult.cpp" />
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\SendError.cpp" />
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\SendObject.cpp" />
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\SendViaBrowserArgs.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\GetSendFilters.cpp" />
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\GetSendSettings.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Send.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\SendBridge.cpp" />
    <ClCompile Include="Connector\Interface\Browser\Bridge\Test\Arg\SayHiArg.cpp" />
@@ -122,6 +127,8 @@
    <ClCompile Include="Connector\Interface\Browser\Bridge\Test\TriggerEvent.cpp" />
    <ClCompile Include="Connector\Interface\ConnectorMenu.cpp" />
    <ClCompile Include="Connector\Interface\ConnectorPalette.cpp" />
+    <ClCompile Include="Connector\Record\Collection\RecordCollection.cpp" />
+    <ClCompile Include="Connector\Record\Collection\RootCollection.cpp" />
    <ClCompile Include="Connector\Record\Model\CardMover.cpp" />
    <ClCompile Include="Connector\Record\Model\CardSetting.cpp" />
    <ClCompile Include="Connector\Record\Model\Filter\DirectSelectionSendFilter.cpp" />
@@ -155,7 +162,12 @@
    <ClInclude Include="Connector\Interface\Browser\Bridge\Config\GetConfig.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Config\GetIsDevMode.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Config\UpdateConfig.h" />
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\ConversionResult.h" />
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendError.h" />
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendObject.h" />
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendViaBrowserArgs.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\GetSendFilters.h" />
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\GetSendSettings.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Send.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\SendBridge.h" />
    <ClInclude Include="Connector\Interface\Browser\Bridge\Test\Arg\SayHiArg.h" />
@@ -166,6 +178,8 @@
    <ClInclude Include="Connector\Interface\Browser\Bridge\Test\TriggerEvent.h" />
    <ClInclude Include="Connector\Interface\ConnectorMenu.h" />
    <ClInclude Include="Connector\Interface\ConnectorPalette.h" />
+    <ClInclude Include="Connector\Record\Collection\RecordCollection.h" />
+    <ClInclude Include="Connector\Record\Collection\RootCollection.h" />
    <ClInclude Include="Connector\Record\Model\CardMover.h" />
    <ClInclude Include="Connector\Record\Model\CardSetting.h" />
    <ClInclude Include="Connector\Record\Model\Filter\ArchicadEverythingFilter.h" />
@@ -59,6 +59,12 @@
    <Filter Include="Connector\Record\Model\Filter">
      <UniqueIdentifier>{b6d6326c-77f4-414a-bda6-e3e587c7ded2}</UniqueIdentifier>
    </Filter>
+    <Filter Include="Connector\Record\Collection">
+      <UniqueIdentifier>{0ac4b0a4-6a2a-4a48-9757-1172effc20e7}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Connector\Interface\Browser\Bridge\Send\Arg">
+      <UniqueIdentifier>{6693f9a9-5ece-4853-b008-4064d1c551ab}</UniqueIdentifier>
+    </Filter>
  </ItemGroup>
  <ItemGroup>
    <None Include="RFIX.win\Connector.rc2">
@@ -198,6 +204,27 @@
    <ClCompile Include="Connector\Interface\Browser\Bridge\Base\UpdateModel.cpp">
      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
    </ClCompile>
+    <ClCompile Include="Connector\Record\Collection\RecordCollection.cpp">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Record\Collection\RootCollection.cpp">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\ConversionResult.cpp">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\SendError.cpp">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\SendViaBrowserArgs.cpp">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\Arg\SendObject.cpp">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClCompile>
+    <ClCompile Include="Connector\Interface\Browser\Bridge\Send\GetSendSettings.cpp">
+      <Filter>Connector\Interface\Browser\Bridge\Send</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Connector\ConnectorResource.h">
@@ -333,5 +360,26 @@
    <ClInclude Include="Connector\Interface\Browser\Bridge\Base\UpdateModel.h">
      <Filter>Connector\Interface\Browser\Bridge\Base</Filter>
    </ClInclude>
+    <ClInclude Include="Connector\Record\Collection\RecordCollection.h">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Record\Collection\RootCollection.h">
+      <Filter>Connector\Record\Collection</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\ConversionResult.h">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendError.h">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendObject.h">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\Arg\SendViaBrowserArgs.h">
+      <Filter>Connector\Interface\Browser\Bridge\Send\Arg</Filter>
+    </ClInclude>
+    <ClInclude Include="Connector\Interface\Browser\Bridge\Send\GetSendSettings.h">
+      <Filter>Connector\Interface\Browser\Bridge\Send</Filter>
+    </ClInclude>
  </ItemGroup>
 </Project>
@@ -29,7 +29,13 @@
 		215F082E2C94C5C000CD343B /* FilterMover.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F082C2C94C5C000CD343B /* FilterMover.cpp */; };
 		215F08372C95808B00CD343B /* ReceiverModelCard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08362C95808B00CD343B /* ReceiverModelCard.cpp */; };
 		215F08462C9633A800CD343B /* EverythingSendFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08452C9633A800CD343B /* EverythingSendFilter.cpp */; };
+		2192460D2CA3469D00CF5703 /* RootCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2192460B2CA3469D00CF5703 /* RootCollection.cpp */; };
 		219F30422C769283009834E9 /* ConfigTests.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219F30402C769282009834E9 /* ConfigTests.cpp */; };
+		21AEF9EB2CAB56E5000B8681 /* SendError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9E32CAB56E5000B8681 /* SendError.cpp */; };
+		21AEF9EC2CAB56E5000B8681 /* SendViaBrowserArgs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9E52CAB56E5000B8681 /* SendViaBrowserArgs.cpp */; };
+		21AEF9EF2CAB5720000B8681 /* SendObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9EE2CAB5720000B8681 /* SendObject.cpp */; };
+		21AEF9F32CAC12D1000B8681 /* SendManager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9F02CAC12D1000B8681 /* SendManager.cpp */; };
+		21AEF9FA2CAC3897000B8681 /* ConversionResult.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9F92CAC3897000B8681 /* ConversionResult.cpp */; };
 		21B67CA32C769CB400FD64FC /* libActiveLib.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 21F69EF52C64FE91008B6A06 /* libActiveLib.a */; };
 		21B67CA42C769CB400FD64FC /* libArchicad27.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 21F69ECD2C64C035008B6A06 /* libArchicad27.a */; };
 		21B67CAC2C77329800FD64FC /* BaseBridge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21B67CA52C77329800FD64FC /* BaseBridge.cpp */; };
@@ -220,6 +226,7 @@
 		21F69F8D2C70D7EE008B6A06 /* GetAccounts.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21F69F8B2C70D7EE008B6A06 /* GetAccounts.cpp */; };
 		21F69FBB2C762EF0008B6A06 /* ConfigBridge.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21F69FB42C762EF0008B6A06 /* ConfigBridge.cpp */; };
 		21F69FBC2C762EF0008B6A06 /* GetConfig.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21F69FB62C762EF0008B6A06 /* GetConfig.cpp */; };
+		21FF70492CA1A7F400AAD99A /* RecordCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21FF70462CA1A7F400AAD99A /* RecordCollection.cpp */; };
 /* End PBXBuildFile section */

 /* Begin PBXContainerItemProxy section */
@@ -298,10 +305,22 @@
 		215F08452C9633A800CD343B /* EverythingSendFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EverythingSendFilter.cpp; sourceTree = "<group>"; };
 		215F084A2C9782F100CD343B /* ArchicadEverythingFilter.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ArchicadEverythingFilter.h; sourceTree = "<group>"; };
 		2161FD902BF2600C006D9527 /* README.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = README.md; sourceTree = "<group>"; };
+		2192460B2CA3469D00CF5703 /* RootCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RootCollection.cpp; sourceTree = "<group>"; };
+		2192460C2CA3469D00CF5703 /* RootCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RootCollection.h; sourceTree = "<group>"; };
 		219388682C4E5DE2002A0180 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; 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; };
+		21AEF9E32CAB56E5000B8681 /* SendError.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SendError.cpp; sourceTree = "<group>"; };
+		21AEF9E42CAB56E5000B8681 /* SendError.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SendError.h; sourceTree = "<group>"; };
+		21AEF9E52CAB56E5000B8681 /* SendViaBrowserArgs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SendViaBrowserArgs.cpp; sourceTree = "<group>"; };
+		21AEF9E62CAB56E5000B8681 /* SendViaBrowserArgs.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SendViaBrowserArgs.h; sourceTree = "<group>"; };
+		21AEF9ED2CAB5720000B8681 /* SendObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SendObject.h; sourceTree = "<group>"; };
+		21AEF9EE2CAB5720000B8681 /* SendObject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SendObject.cpp; sourceTree = "<group>"; };
+		21AEF9F02CAC12D1000B8681 /* SendManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SendManager.cpp; sourceTree = "<group>"; };
+		21AEF9F12CAC12D1000B8681 /* SendManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SendManager.h; sourceTree = "<group>"; };
+		21AEF9F82CAC3897000B8681 /* ConversionResult.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConversionResult.h; sourceTree = "<group>"; };
+		21AEF9F92CAC3897000B8681 /* ConversionResult.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ConversionResult.cpp; sourceTree = "<group>"; };
 		21B67CA52C77329800FD64FC /* BaseBridge.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BaseBridge.cpp; sourceTree = "<group>"; };
 		21B67CA62C77329800FD64FC /* BaseBridge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BaseBridge.h; sourceTree = "<group>"; };
 		21B67CA72C77329800FD64FC /* GetSourceApplicationName.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GetSourceApplicationName.cpp; sourceTree = "<group>"; };
@@ -534,6 +553,8 @@
 		21F69FB72C762EF0008B6A06 /* GetConfig.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GetConfig.h; sourceTree = "<group>"; };
 		21F69FBD2C7630B3008B6A06 /* UpdateConfig.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UpdateConfig.cpp; sourceTree = "<group>"; };
 		21F69FBE2C7630B3008B6A06 /* UpdateConfig.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UpdateConfig.h; sourceTree = "<group>"; };
+		21FF70462CA1A7F400AAD99A /* RecordCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RecordCollection.cpp; sourceTree = "<group>"; };
+		21FF70472CA1A7F400AAD99A /* RecordCollection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RecordCollection.h; sourceTree = "<group>"; };
 /* End PBXFileReference section */

 /* Begin PBXFrameworksBuildPhase section */
@@ -939,6 +960,30 @@
 			path = ConnectorTests;
 			sourceTree = "<group>";
 		};
+		21AEF9E72CAB56E5000B8681 /* Arg */ = {
+			isa = PBXGroup;
+			children = (
+				21AEF9F92CAC3897000B8681 /* ConversionResult.cpp */,
+				21AEF9F82CAC3897000B8681 /* ConversionResult.h */,
+				21AEF9E32CAB56E5000B8681 /* SendError.cpp */,
+				21AEF9E42CAB56E5000B8681 /* SendError.h */,
+				21AEF9EE2CAB5720000B8681 /* SendObject.cpp */,
+				21AEF9ED2CAB5720000B8681 /* SendObject.h */,
+				21AEF9E52CAB56E5000B8681 /* SendViaBrowserArgs.cpp */,
+				21AEF9E62CAB56E5000B8681 /* SendViaBrowserArgs.h */,
+			);
+			path = Arg;
+			sourceTree = "<group>";
+		};
+		21AEF9F22CAC12D1000B8681 /* Serialise */ = {
+			isa = PBXGroup;
+			children = (
+				21AEF9F02CAC12D1000B8681 /* SendManager.cpp */,
+				21AEF9F12CAC12D1000B8681 /* SendManager.h */,
+			);
+			path = Serialise;
+			sourceTree = "<group>";
+		};
 		21B67CAB2C77329800FD64FC /* Base */ = {
 			isa = PBXGroup;
 			children = (
@@ -1023,6 +1068,7 @@
 		21D0BD5D2C89BFEA0077E104 /* Send */ = {
 			isa = PBXGroup;
 			children = (
+				21AEF9E72CAB56E5000B8681 /* Arg */,
 				21D0BD962C8F13F30077E104 /* GetSendFilters.cpp */,
 				21D0BD952C8F13F30077E104 /* GetSendFilters.h */,
 				21D0BD8D2C8EE4490077E104 /* Send.cpp */,
@@ -1036,6 +1082,7 @@
 		21D0BDD82C9387E60077E104 /* Record */ = {
 			isa = PBXGroup;
 			children = (
+				21FF70482CA1A7F400AAD99A /* Collection */,
 				21D0BDD92C9387F70077E104 /* Model */,
 			);
 			path = Record;
@@ -1136,6 +1183,7 @@
 				21F69F092C677BC0008B6A06 /* Event */,
 				21F69F0E2C677BC0008B6A06 /* Interface */,
 				21D0BDD82C9387E60077E104 /* Record */,
+				21AEF9F22CAC12D1000B8681 /* Serialise */,
 				21B67CBA2C774C6500FD64FC /* Version.h */,
 			);
 			path = Connector;
@@ -1188,6 +1236,17 @@
 			path = Config;
 			sourceTree = "<group>";
 		};
+		21FF70482CA1A7F400AAD99A /* Collection */ = {
+			isa = PBXGroup;
+			children = (
+				21FF70462CA1A7F400AAD99A /* RecordCollection.cpp */,
+				21FF70472CA1A7F400AAD99A /* RecordCollection.h */,
+				2192460B2CA3469D00CF5703 /* RootCollection.cpp */,
+				2192460C2CA3469D00CF5703 /* RootCollection.h */,
+			);
+			path = Collection;
+			sourceTree = "<group>";
+		};
 		7EA5F91E157FA18400693CEA /* EN-GB */ = {
 			isa = PBXGroup;
 			children = (
@@ -1393,8 +1452,10 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				21AEF9FA2CAC3897000B8681 /* ConversionResult.cpp in Sources */,
 				21D0BDAB2C8F363E0077E104 /* CardSetting.cpp in Sources */,
 				21B67CE32C78D1FB00FD64FC /* SayHiArg.cpp in Sources */,
+				21AEF9EB2CAB56E5000B8681 /* SendError.cpp in Sources */,
 				215F08462C9633A800CD343B /* EverythingSendFilter.cpp in Sources */,
 				21F69FBB2C762EF0008B6A06 /* ConfigBridge.cpp in Sources */,
 				21F69F8A2C70D2C4008B6A06 /* AccountBridge.cpp in Sources */,
@@ -1407,12 +1468,16 @@
 				21D0BD602C89BFEA0077E104 /* SendBridge.cpp in Sources */,
 				21D0BD972C8F13F30077E104 /* GetSendFilters.cpp in Sources */,
 				21B67CAC2C77329800FD64FC /* BaseBridge.cpp in Sources */,
+				2192460D2CA3469D00CF5703 /* RootCollection.cpp in Sources */,
 				21D0BD6A2C8A0DB40077E104 /* GetIsDevMode.cpp in Sources */,
+				21AEF9F32CAC12D1000B8681 /* SendManager.cpp in Sources */,
 				210CC8832C80E6A300610F58 /* TriggerEvent.cpp in Sources */,
 				21B67CEB2C78D27200FD64FC /* DocumentInfo.cpp in Sources */,
 				21B67CB92C774BFA00FD64FC /* GetConnectorVersion.cpp in Sources */,
 				21B67CD92C78C83800FD64FC /* TestBridge.cpp in Sources */,
 				214B7A372C764BCD00D586C1 /* UpdateConfig.cpp in Sources */,
+				21AEF9EC2CAB56E5000B8681 /* SendViaBrowserArgs.cpp in Sources */,
+				21FF70492CA1A7F400AAD99A /* RecordCollection.cpp in Sources */,
 				21B67CC02C775A0D00FD64FC /* GetDocumentInfo.cpp in Sources */,
 				21D0BDD42C935D1A0077E104 /* UpdateModel.cpp in Sources */,
 				21B67CE72C78D23B00FD64FC /* ConnectorConfig.cpp in Sources */,
@@ -1422,6 +1487,7 @@
 				215F082A2C947F4400CD343B /* CardMover.cpp in Sources */,
 				215F08372C95808B00CD343B /* ReceiverModelCard.cpp in Sources */,
 				21D0BDD72C935DAE0077E104 /* RemoveModel.cpp in Sources */,
+				21AEF9EF2CAB5720000B8681 /* SendObject.cpp in Sources */,
 				21B67CDC2C78C88000FD64FC /* SayHi.cpp in Sources */,
 				215F082E2C94C5C000CD343B /* FilterMover.cpp in Sources */,
 				21F69F122C677BC0008B6A06 /* ConnectorMenu.cpp in Sources */,
@@ -2,8 +2,8 @@
 #include "ConnectorResource.h"
 #include "Connector/Connector.h"
 #include "Connector/Database/ModelCardDatabase.h"
-#include "Interface/ConnectorMenu.h"
-#include "Interface/ConnectorPalette.h"
+#include "Connector/Interface/ConnectorMenu.h"
+#include "Connector/Interface/ConnectorPalette.h"
 #include "Speckle/Database/AccountDatabase.h"
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/Utility/String.h"
@@ -35,16 +35,16 @@ namespace {
 		
 		// MARK: Functions (const)
 		
-		/*!
-		 Get the model card database
-		 @return The model card database
-		 */
-		const ModelCardDatabase* getModelCardDatabase() const override { return &m_modelCards; }
 		/*!
 		 Get the account database
 		 @return The account database
 		 */
 		const AccountDatabase* getAccountDatabase() const override;
+		/*!
+		 Get the model card database
+		 @return The model card database
+		 */
+		const ModelCardDatabase* getModelCardDatabase() const override { return &m_modelCards; }
 		
 	private:
 		mutable std::unique_ptr<AccountDatabase> m_account;
@@ -3,6 +3,7 @@

 namespace speckle::database {
 	class AccountDatabase;
+	class BIMElementDatabase;
 }
 namespace connector::database {
 	class ModelCardDatabase;
@@ -16,16 +17,16 @@ namespace connector {
 		
 		// MARK: Functions (const)
 		
-		/*!
-		 Get the model card database
-		 @return The model card database
-		 */
-		const virtual database::ModelCardDatabase* getModelCardDatabase() const = 0;
 		/*!
 		 Get the account database
 		 @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:
 		/*!
@@ -37,7 +37,7 @@ enum PromptString {


 	//Information strings (in UI content, logging, reports)
-enum InfoString {
+enum GeneralString {
 };


@@ -53,6 +53,10 @@ enum WarningString {

 	//Error strings (errors displayed in alerts)
 enum ErrorString {
+	noSelectedModelItemsID = 1,
+	modelCardNotFoundID,
+	noProjectOpenID,
+	accountNotFoundID,
 };

 #endif	//CONNECTOR_RESOURCE
@@ -71,6 +71,16 @@ ModelCardDatabase::ModelCardDatabase() {
 ModelCardDatabase::~ModelCardDatabase() {}


+/*--------------------------------------------------------------------
+	Get a specified card from the database
+ 
+	return: The requested card (nullptr on failure)
+  --------------------------------------------------------------------*/
+ModelCard::Unique ModelCardDatabase::getCard(const speckle::utility::String& cardID) const {
+	return m_store->getObject(cardID);
+} //ModelCardDatabase::getCard
+
+
 /*--------------------------------------------------------------------
 	Get all model cards
 
@@ -101,6 +111,16 @@ void ModelCardDatabase::erase(const String& cardID) const {
 } //ModelCardDatabase::erase


+/*--------------------------------------------------------------------
+	Get the unique ID of the engine storage
+ 
+	return: The databas unique ID
+  --------------------------------------------------------------------*/
+RecordID ModelCardDatabase::getStoreID() const {
+	return m_engine->getUniqueID();
+} //ModelCardDatabase::getStoreID
+
+
 /*--------------------------------------------------------------------
 	Get a serialisation wrapper for the database
 
@@ -29,6 +29,11 @@ namespace connector::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Get a specified card from the database
+		 @return The requested card (nullptr on failure)
+		 */
+		record::ModelCard::Unique getCard(const speckle::utility::String& cardID) const;
 		/*!
 		 Get all model cards
 		 @return All the cards
@@ -49,6 +54,11 @@ namespace connector::database {
 		 @return A database wrapper
 		 */
 		std::unique_ptr<active::serialise::Cargo> wrapper() const;
+		/*!
+		 Get the unique ID of the engine storage
+		 @return The database unique ID
+		 */
+		speckle::database::RecordID getStoreID() const;
 		
 		// MARK: - Functions (mutating)

@@ -2,6 +2,7 @@

 #include "Active/Serialise/CargoHold.h"
 #include "Connector/Connector.h"
+#include "Connector/Database/ModelCardDatabase.h"
 #include "Connector/Interface/Browser/Bridge/Base/Arg/DocumentInfo.h"
 #include "Speckle/Environment/Project.h"
 #include "Speckle/Utility/Guid.h"
@@ -37,7 +38,8 @@ std::unique_ptr<Cargo> GetDocumentInfo::run() const {
 		docInfo->name = info.name;
 		if (info.path)
 			docInfo->location = *info.path;
-			//TODO: No suitable project ID is currently available
+		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));
@@ -1,7 +1,6 @@
 #include "Connector/Interface/Browser/Bridge/Base/GetDocumentState.h"

 #include "Active/Serialise/CargoHold.h"
-#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
 #include "Connector/Connector.h"
 #include "Connector/Record/Model/ModelCard.h"
 #include "Connector/Database/ModelCardDatabase.h"
@@ -0,0 +1,65 @@
+#include "Connector/Interface/Browser/Bridge/Send/Arg/ConversionResult.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+
+#include <array>
+
+using namespace active::serialise;
+using namespace connector::interfac::browser::bridge;
+using namespace speckle::utility;
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		errorID,
+		cardID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"error"},
+		Identity{"modelCardId"},
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	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 ConversionResult::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[errorID], errorID, element },
+			{ fieldID[cardID], cardID, element },
+		},
+	}.withType(&typeid(ConversionResult)));
+	return true;
+} //ConversionResult::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique ConversionResult::getCargo(const active::serialise::Inventory::Item& item) const {
+	if (item.ownerType != &typeid(ConversionResult))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case errorID:
+			return std::make_unique<ValueWrap<String>>(message);
+		case cardID:
+			return std::make_unique<ValueWrap<String>>(modelCardID);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //ConversionResult::getCargo
@@ -0,0 +1,68 @@
+#ifndef CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
+#define CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
+
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
+#include "Speckle/Utility/String.h"
+
+namespace connector::interfac::browser::bridge {
+	
+	/*!
+	 A send error to return to the JS in the event of an error
+	 */
+	class ConversionResult final : public active::serialise::Package {
+	public:
+		enum class Status {
+			success = 1,
+			info,
+			warning,
+			error,
+		};
+				
+		// MARK: - Constructors
+		
+		/*!
+			Constructor
+			@param errMess The error message
+			@param card The ID of the model card associated with the wrror
+		*/
+		ConversionResult(const speckle::utility::String& errMess, const speckle::utility::String& card) : message{errMess}, modelCardID{card} {}
+				
+		// MARK: - Public variables
+		
+			///The error message
+		speckle::utility::String message;
+			///The ID of the model card associated with the data
+		speckle::utility::String modelCardID;
+			///The element conversion status
+		Status status = Status::info;
+			///For receive conversion reports, this is the id of the speckle object. For send, it's the host app object id.
+		speckle::utility::String sourceId;
+			///For receive conversion reports, this is the type of the speckle object. For send, it's the host app object type.
+		speckle::utility::String sourceType;
+			///For receive conversion reports, this is the id of the host app object. For send, it's the speckle object id.
+		speckle::utility::String resultId;
+			///For receive conversion reports, this is the type of the host app object. For send, it's the speckle object type.
+		speckle::utility::String resultType;
+			///The exception (nullopt = no exception)
+		SendError::Option error;
+
+		// 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;
+	};
+
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_SEND_CONVERSION_RESULT
@@ -0,0 +1,65 @@
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+
+#include <array>
+
+using namespace active::serialise;
+using namespace connector::interfac::browser::bridge;
+using namespace speckle::utility;
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		errorID,
+		cardID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"error"},
+		Identity{"modelCardId"},
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	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 SendError::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[errorID], errorID, element },
+			{ fieldID[cardID], cardID, element },
+		},
+	}.withType(&typeid(SendError)));
+	return true;
+} //SendError::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique SendError::getCargo(const active::serialise::Inventory::Item& item) const {
+	if (item.ownerType != &typeid(SendError))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case errorID:
+			return std::make_unique<ValueWrap<String>>(message);
+		case cardID:
+			return std::make_unique<ValueWrap<String>>(modelCardID);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //SendError::getCargo
@@ -0,0 +1,54 @@
+#ifndef CONNECTOR_INTERFACE_BRIDGE_SEND_ERROR
+#define CONNECTOR_INTERFACE_BRIDGE_SEND_ERROR
+
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Speckle/Utility/String.h"
+
+namespace connector::interfac::browser::bridge {
+	
+	/*!
+	 A send error to return to the JS in the event of an error
+	 */
+	class SendError final : public active::serialise::Package {
+	public:
+		
+		// MARK: Types
+		
+			///Optional
+		using Option = std::optional<SendError>;
+				
+		// MARK: - Constructors
+		
+		/*!
+			Constructor
+			@param errMess The error message
+			@param card The ID of the model card associated with the wrror
+		*/
+		SendError(const speckle::utility::String& errMess, const speckle::utility::String& card) : message{errMess}, modelCardID{card} {}
+				
+		// MARK: - Public variables
+		
+			///The error message
+		speckle::utility::String message;
+			///The ID of the model card associated with the data
+		speckle::utility::String modelCardID;
+
+		// 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;
+	};
+
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_SEND_ERROR
@@ -0,0 +1,71 @@
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendObject.h"
+
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+
+#include <array>
+
+using namespace active::serialise;
+using namespace connector::interfac::browser::bridge;
+using namespace speckle::serialise;
+using namespace speckle::utility;
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		idID,
+		totChildID,
+		batchesID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"id"},
+		Identity{"totalChildrenCount"},
+		Identity{"batches"},
+	};
+	
+}
+
+/*--------------------------------------------------------------------
+	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 SendObject::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[idID], idID, element },
+			{ fieldID[totChildID], totChildID, element },
+			{ fieldID[batchesID], batchesID, element },
+		},
+	}.withType(&typeid(SendObject)));
+	return true;
+} //SendObject::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique SendObject::getCargo(const active::serialise::Inventory::Item& item) const {
+	if (item.ownerType != &typeid(SendObject))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case idID:
+			return std::make_unique<StringWrap>(id);
+		case totChildID:
+			return std::make_unique<Int32Wrap>(totalChildrenCount);
+		case batchesID:
+			return std::make_unique<ContainerWrap<std::vector<speckle::utility::String>>>(batches);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //SendObject::getCargo
@@ -0,0 +1,53 @@
+#ifndef CONNECTOR_INTERFACE_BRIDGE_SEND_OBJECT
+#define CONNECTOR_INTERFACE_BRIDGE_SEND_OBJECT
+
+#include "Active/Serialise/CargoHold.h"
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Connector/Interface/Browser/Bridge/Config/Arg/ConnectorConfig.h"
+#include "Speckle/Interface/Browser/Bridge/BridgeMethod.h"
+
+namespace connector::interfac::browser::bridge {
+	
+	/*!
+	 Class defining the primary content of a send
+	 */
+	class SendObject final : public active::serialise::Package {
+	public:
+				
+		// MARK: - Constructors
+		
+		/*!
+			Constructor
+			@param errMess The error message
+			@param card The ID of the model card associated with the wrror
+		*/
+		SendObject() {}
+				
+		// MARK: - Public variables
+		
+			///The root object id which should be used for creating the version
+		speckle::utility::String id = "1234asdasdsadsadsa";
+			///The total number of children
+		int32_t totalChildrenCount = 0;
+			///JSON batches for the root object and child (detached) objects
+		std::vector<speckle::utility::String> batches = { "[{\"speckle_type\": \"Base\", \"id\" : \"1234asdasdsadsadsa\"}]" }; // NOTE to Ralph: it will be stringified but like array of objects as in example
+
+		// 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;
+	};
+
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_SEND_OBJECT
@@ -0,0 +1,113 @@
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendViaBrowserArgs.h"
+
+#include "Connector/Record/Model/ModelCard.h"
+#include "Speckle/Record/Credentials/Account.h"
+
+#include <array>
+
+using namespace active::serialise;
+using namespace connector::record;
+using namespace connector::interfac::browser::bridge;
+using namespace speckle::database;
+using namespace speckle::record::cred;
+using namespace speckle::serialise;
+using namespace speckle::utility;
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		cardID,
+		projID,
+		modID,
+		tokenID,
+		serverID,
+		accID,
+		messageID,
+		sendObjectID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"modelCardId"},
+		Identity{"projectId"},
+		Identity{"modelId"},
+		Identity{"token"},
+		Identity{"serverUrl"},
+		Identity{"accountId"},
+		Identity{"message"},
+		Identity{"sendObject"},
+	};
+	
+}
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	modelCard: The model card to populate into the send info for the browser
+	account: The account linked to the send
+  --------------------------------------------------------------------*/
+SendViaBrowserArgs::SendViaBrowserArgs(const ModelCard& modelCard, const Account& account) :
+		modelCardID(modelCard.getID()), projectID(modelCard.getProjectID()), modelID(modelCard.getModelID()), token{account.getToken()},
+		serverURL{account.getServerURL()}, accountID{account.getID()} {
+	
+} //SendViaBrowserArgs::SendViaBrowserArgs
+
+
+/*--------------------------------------------------------------------
+	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 SendViaBrowserArgs::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[cardID], cardID, element },
+			{ fieldID[projID], projID, element },
+			{ fieldID[modID], modID, element },
+			{ fieldID[tokenID], tokenID, element },
+			{ fieldID[serverID], serverID, element },
+			{ fieldID[accID], accID, element },
+			{ fieldID[messageID], messageID, element },
+			{ fieldID[sendObjectID], sendObjectID, element },
+		},
+	}.withType(&typeid(SendViaBrowserArgs)));
+	return true;
+} //SendViaBrowserArgs::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique SendViaBrowserArgs::getCargo(const active::serialise::Inventory::Item& item) const {
+	if (item.ownerType != &typeid(SendViaBrowserArgs))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case cardID:
+			return std::make_unique<StringWrap>(modelCardID);
+		case projID:
+			return std::make_unique<StringWrap>(projectID);
+		case modID:
+			return std::make_unique<StringWrap>(modelID);
+		case tokenID:
+			return std::make_unique<StringWrap>(token);
+		case serverID:
+			return std::make_unique<StringWrap>(serverURL);
+		case accID:
+			return std::make_unique<StringWrap>(accountID);
+		case messageID:
+			return std::make_unique<StringWrap>(message);
+		case sendObjectID:
+			return std::make_unique<PackageWrap>(sendObject);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //SendViaBrowserArgs::getCargo
@@ -0,0 +1,78 @@
+#ifndef CONNECTOR_INTERFACE_BRIDGE_SEND_VIA_BROWSER_ARGS
+#define CONNECTOR_INTERFACE_BRIDGE_SEND_VIA_BROWSER_ARGS
+
+#include "Active/Serialise/Package/Package.h"
+#include "Active/Utility/String.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/ConversionResult.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendObject.h"
+#include "Speckle/Database/Identity/RecordID.h"
+
+namespace speckle::record::cred {
+	class Account;
+}
+
+namespace connector::record {
+	class ModelCard;
+}
+
+namespace connector::interfac::browser::bridge {
+	
+	class ConnectorConfig;
+	
+	/*!
+	 A commit of a project version (model) to the Speckle server
+	 
+	 An object of this type is prepared by the Send bridge method
+	 */
+	class SendViaBrowserArgs final : public active::serialise::Package {
+	public:
+				
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param modelCard The model card to populate into the send info for the browser
+		 @param account The account linked to the send
+		 */
+		SendViaBrowserArgs(const connector::record::ModelCard& modelCard, const speckle::record::cred::Account& account);
+				
+		// MARK: - Public variables
+		
+			///ID of the model card driving the send request
+		speckle::database::RecordID modelCardID;
+			///The source project ID (from the model card)
+		speckle::database::RecordID projectID;
+			///The model ID (from the model card)
+		speckle::database::RecordID modelID;
+			///The account token (from the user account info)
+		speckle::utility::String token;
+			///The server URL (from the user account info)
+		speckle::utility::String serverURL;
+			///The user account ID
+		speckle::utility::String accountID;
+			///The send message
+		speckle::utility::String message;	//TODO: Clarify what this is used for
+			///The conversion report (summarising the conversion results on an element-by-element basis)
+		std::vector<ConversionResult> sendConversionResults;
+			///The commit content
+		SendObject sendObject;
+
+		// 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;
+	};
+
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_SEND_VIA_BROWSER_ARGS
@@ -0,0 +1,36 @@
+#include "Connector/Interface/Browser/Bridge/Send/GetSendSettings.h"
+
+#include "Active/Container/Vector.h"
+#include "Active/Serialise/CargoHold.h"
+#include "Active/Serialise/Package/Wrapper/ContainerWrap.h"
+#include "Connector/Record/Model/CardSetting.h"
+
+using namespace active::container;
+using namespace active::serialise;
+using namespace connector::record;
+using namespace connector::interfac::browser::bridge;
+using namespace speckle::utility;
+
+namespace {
+	
+	using WrappedValue = active::serialise::CargoHold<ContainerWrap<Vector<CardSetting>, PackageWrap>, Vector<CardSetting>>;
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+GetSendSettings::GetSendSettings() : BridgeMethod{"GetSendSettings", [&]() {
+		return run();
+}} {}
+
+
+/*--------------------------------------------------------------------
+	Get the send filters
+ 
+	return: The send filters
+  --------------------------------------------------------------------*/
+std::unique_ptr<Cargo> GetSendSettings::run() const {
+	auto filters = std::make_unique<Vector<CardSetting>>();
+	return std::make_unique<WrappedValue>(std::move(filters));
+} //GetSendSettings::run
@@ -0,0 +1,36 @@
+#ifndef CONNECTOR_INTERFACE_BRIDGE_GET_SEND_SETTINGS
+#define CONNECTOR_INTERFACE_BRIDGE_GET_SEND_SETTINGS
+
+#include "Active/Serialise/CargoHold.h"
+#include "Speckle/Interface/Browser/Bridge/BridgeMethod.h"
+
+namespace connector::interfac::browser::bridge {
+	
+	class ConnectorConfig;
+	
+	/*!
+	 JS Function class to retrieve the send filters
+	*/
+	class GetSendSettings : public speckle::interfac::browser::bridge::BridgeMethod<void, active::serialise::Cargo> {
+	public:
+
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param bridge The parent bridge object (provides access to bridge methods)
+		 */
+		GetSendSettings();
+
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the send filters
+		 @return The send filters
+		 */
+		std::unique_ptr<active::serialise::Cargo> run() const;
+	};
+
+}
+
+#endif	//CONNECTOR_INTERFACE_BRIDGE_GET_SEND_SETTINGS
@@ -2,12 +2,27 @@

 #include "Active/Serialise/CargoHold.h"
 #include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Connector/Connector.h"
+#include "Connector/ConnectorResource.h"
+#include "Connector/Database/ModelCardDatabase.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendError.h"
+#include "Connector/Interface/Browser/Bridge/Send/Arg/SendViaBrowserArgs.h"
+#include "Speckle/Database/AccountDatabase.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"

 using namespace active::serialise;
 using namespace connector::interfac::browser::bridge;
+using namespace speckle::database;
+using namespace speckle::serialise;
 using namespace speckle::utility;

+namespace {
+		
+}
+
 /*--------------------------------------------------------------------
 	Default constructor
  --------------------------------------------------------------------*/
@@ -19,9 +34,34 @@ Send::Send() : BridgeMethod{"Send", [&](const SendArgs& args) {
 /*--------------------------------------------------------------------
 	Send a specified model
 
-	modelCardID: The ID of the madel to send
+	modelCardID: The ID of the model to send
  --------------------------------------------------------------------*/
 void Send::run(const String& modelCardID) const {
-		///TODO: Find and send selected elements - the following is a placeholder
-	throw Exception{"No objects were found to convert. Please update your publish filter!"};
+		//Find the specified model card
+	auto modelCardDatabase = connector()->getModelCardDatabase();
+	auto modelCard = modelCardDatabase->getCard(modelCardID);
+	if (!modelCard) {
+		getBridge()->sendEvent("setModelError",
+					std::make_unique<SendError>(connector()->getLocalString(errorString, modelCardNotFoundID), modelCardID));
+		return;
+	}
+	auto accountDatabase = connector()->getAccountDatabase();
+	auto account = accountDatabase->getAccount(modelCard->getAccountID(), modelCard->getServerURL());
+	if (!account) {
+		getBridge()->sendEvent("setModelError",
+					std::make_unique<SendError>(connector()->getLocalString(errorString, accountNotFoundID), modelCardID));
+		return;
+	}
+		//Get the active project
+	auto project = connector()->getActiveProject().lock();
+	if (!project) {
+		getBridge()->sendEvent("setModelError",
+					std::make_unique<SendError>(connector()->getLocalString(errorString, noProjectOpenID), modelCardID));
+		return;
+	}
+		//We currently collect all detached object serialised data into a memory-based store - in future may be able to batch send and cache locally
+	DetachedMemoryStore detachedObjects;
+	auto result = std::make_unique<SendViaBrowserArgs>(*modelCard, *account);
+	
+	getBridge()->sendEvent("sendByBrowser", std::move(result));
 } //Send::run
@@ -33,7 +33,7 @@ namespace connector::interfac::browser::bridge {
 		
 		/*!
 		 Send a specified model
-		 @param modelCardID The ID of the madel to send
+		 @param modelCardID The ID of the model to send
 		 */
 		void run(const speckle::utility::String& modelCardID) const;
 	};
@@ -1,6 +1,7 @@
 #include "Connector/Interface/Browser/Bridge/Send/SendBridge.h"

 #include "Connector/Interface/Browser/Bridge/Send/GetSendFilters.h"
+#include "Connector/Interface/Browser/Bridge/Send/GetSendSettings.h"
 #include "Connector/Interface/Browser/Bridge/Send/Send.h"

 using namespace connector::interfac::browser::bridge;
@@ -11,5 +12,6 @@ using namespace connector::interfac::browser::bridge;
 SendBridge::SendBridge() : BrowserBridge{"sendBinding"} {
 		//Add bridge methods
 	addMethod<GetSendFilters>();
+	addMethod<GetSendSettings>();
 	addMethod<Send>();
 } //SendBridge::SendBridge
@@ -12,6 +12,14 @@
 #include "Speckle/Event/Type/MenuEvent.h"
 #include "Speckle/Interface/Browser/JSPortal.h"

+
+#include "Speckle/Environment/Project.h"
+
+
+#include "Connector/Connector.h"
+#include "Speckle/Database/BIMElementDatabase.h"
+
+
 #include <ACAPinc.h>
 #include <DGModule.hpp>
 #include <DGBrowser.hpp>
@@ -0,0 +1,75 @@
+#include "Connector/Record/Collection/RecordCollection.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+
+using namespace active::serialise;
+using namespace connector::record;
+using namespace speckle::database;
+using namespace speckle::utility;
+
+#include <array>
+
+namespace {
+
+		///Serialisation fields
+	enum FieldIndex {
+		nameID,
+		elementID,
+		childrenID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"name"},
+		Identity{"element"},
+		Identity{"child"},
+	};
+
+}
+
+
+/*--------------------------------------------------------------------
+	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 RecordCollection::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[nameID], nameID, element },
+			{ fieldID[elementID], elementID, base::size(), std::nullopt, !base::empty() },
+			{ fieldID[childrenID], childrenID, m_children.size(), std::nullopt, !m_children.empty() },
+		},
+	}.withType(&typeid(RecordCollection)));
+	return true;
+} //RecordCollection::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique RecordCollection::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(RecordCollection))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case nameID:
+			return std::make_unique<StringWrap>(m_name);
+		case elementID:
+			return nullptr;	//TODO: Implement - need to interrogate BIM database for element and return as cargo
+		case childrenID:
+			if (item.available < m_children.size())
+				return std::make_unique<PackageWrap>(m_children[item.available]);
+			return nullptr;
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //RecordCollection::getCargo
@@ -0,0 +1,91 @@
+#ifndef CONNECTOR_RECORD_RECORD_COLLECTiON
+#define CONNECTOR_RECORD_RECORD_COLLECTiON
+
+#include "Active/Container/Vector.h"
+#include "Active/Serialise/Package/Package.h"
+#include "Speckle/Database/Identity/RecordID.h"
+#include "Speckle/Utility/String.h"
+
+namespace connector::record {
+	
+	/*!
+	 Container for a collection of elements (and potentially tables of associated attributes) for Speckle commits
+	 
+	 The container only stores element indices - database operations (including serialisation) will lookup records from a specified  BIMDatabase on
+	 demand.
+	 
+	 This container can used hierarchically, so an collection can be nested within another collection. The current structure is:
+	 - Root
+	 	- Element containers dividing elements by level/storey
+	 		- Element containers dividing elements by classification
+	 			- [nested classification leaf nodes)
+	 	- Associated attributes, e.g. classification table (future)
+	 
+	 Any level in the hierarchy may contain element indices, although this is currently unlikely at the root level (all elements have a level/storey)
+	 Each container should be named appropriately, e.g. a level/storey collection should be named to match the level/storey.
+	 
+	 Note that the serialisation is currently implemented for sending only. Receive can be added as required
+	 */
+	class RecordCollection : public std::vector<speckle::database::RecordID>, public active::serialise::Package {
+	public:
+		
+		// MARK: - Types
+		
+		using base = std::vector<speckle::database::RecordID>;
+		using Children = std::vector<RecordCollection>;
+		
+		// MARK: - Constructors
+		
+		using base::base;
+				
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the container name
+		 @return The container name
+		 */
+		const speckle::utility::String& getName() const { return m_name; }
+		/*!
+		 Get the child collections
+		 @return The child collections nested under this collection
+		 */
+		const Children& getChildren() const;
+				
+		// MARK: - Functions (mutating)
+		
+		/*!
+		 Set the container name
+		 @param name The container name
+		 */
+		void setName(const speckle::utility::String& name) { m_name = name; }
+		/*!
+		 Add a child collection
+		 @param child The child collection to add
+		 */
+		void addChild(RecordCollection&& child);
+		
+		// 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)
+		*/
+		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		
+	private:
+			///Child nodes of this collection
+		Children m_children;
+			///The collection name
+		speckle::utility::String m_name;
+	};
+	
+}
+
+#endif	//CONNECTOR_RECORD_RECORD_COLLECTiON
@@ -0,0 +1,34 @@
+#include "Connector/Record/Collection/RootCollection.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+
+using namespace active::serialise;
+using namespace connector::record;
+using namespace speckle::database;
+using namespace speckle::utility;
+
+/*--------------------------------------------------------------------
+	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 RootCollection::fillInventory(Inventory& inventory) const {
+		//Extend with supplementary data as required
+	return base::fillInventory(inventory);
+} //RootCollection::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique RootCollection::getCargo(const Inventory::Item& item) const {
+		//Extend with supplementary data as required
+	return base::getCargo(item);
+} //RootCollection::getCargo
@@ -0,0 +1,52 @@
+#ifndef CONNECTOR_RECORD_ROOT_COLLECTiON
+#define CONNECTOR_RECORD_ROOT_COLLECTiON
+
+#include "Connector/Record/Collection/RecordCollection.h"
+
+namespace connector::record {
+	
+	/*!
+	 Root container for sending model data to a Speckle server
+	 
+	 Additional information is anticipated at the root level that will not apply at any other level in the container hierarchy, e.g.:
+	 - Classification hierarchy
+	 - Layers
+	 - Other attributes, e.g. materials
+	 Add all this supplementary data to the root container as required
+	 */
+	class RootCollection : public RecordCollection {
+	public:
+		
+		// MARK: - Types
+		
+		using base = RecordCollection;
+		
+		// MARK: - Constructors
+		
+		using base::base;
+				
+		// MARK: - Functions (const)
+		
+				
+		// MARK: - Functions (mutating)
+		
+		
+		// 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)
+		*/
+		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+	};
+	
+}
+
+#endif	//CONNECTOR_RECORD_ROOT_COLLECTiON
@@ -19,6 +19,8 @@ namespace connector::record {
 		// MARK: - Types
 		
 		using base = speckle::database::Record;
+			///Unique pointer
+		using Unique = std::unique_ptr<ModelCard>;
 			//List of card settings
 		using SettingList = active::container::Vector<connector::record::CardSetting>;

@@ -67,6 +69,11 @@ namespace connector::record {
 		 @return The setting type
 		 */
 		const speckle::utility::String& getAccountID() const { return m_accountID; }
+		/*!
+		 Get the user commit message
+		 @return The user commit message
+		 */
+		const speckle::utility::String& getMessage() const { return m_message; }
 		/*!
 		 Get the setting type
 		 @return The setting type
@@ -106,6 +113,8 @@ namespace connector::record {
 		speckle::database::RecordID m_accountID;
 			///The server URL
 		speckle::utility::String m_serverURL;
+			///The commit message from the user for the card
+		speckle::utility::String m_message;
 			///Settings for the model rendering, e.g. level of detail (LoD)
 		SettingList m_settings;
 			///True if the card has expired
@@ -2,3 +2,10 @@
 /* [  1] */		"Speckle Connector"
 /* [  2] */		"Connector to share model content with Speckle"
 }
+
+'STR#' 32604 "Error strings" {
+/* [  1] */		"No objects were found to convert. Please update your publish filter!"
+/* [  2] */		"The specified model card cannot be found. Try another card or create a new one"
+/* [  3] */		"Please open a project first"
+/* [  4] */		"The specified Speckle account cannot be found. Check that you have logged into your Speckle account with the Speckle Manager"
+}
@@ -81,6 +81,27 @@ AccountDatabase::AccountDatabase(const active::file::Path& path) {
 AccountDatabase::~AccountDatabase() {}


+/*--------------------------------------------------------------------
+	Get a specified account. NB: The server URL is provided as a fallback for the search if the specified accountID is not found
+ 
+	accountID: The account ID (the primary search field)
+	serverURL: The server URL (a fallback search field if the account ID does not exist)
+ 
+	return: The requested account (nullptr on failure)
+  --------------------------------------------------------------------*/
+std::unique_ptr<Account> AccountDatabase::getAccount(const String& accountID, const String& serverURL) const {
+		//First attempt to find a matching account ID
+	auto matchingAccount = m_store->getObjects([&accountID](const auto& acc) { return acc.getID() == accountID; });
+	if (!matchingAccount.empty())
+		return matchingAccount.release(matchingAccount.begin());
+		//Alternatively seek an account with a matching server URL
+	matchingAccount = m_store->getObjects([&serverURL](const auto& acc) { return acc.getServerURL() == serverURL; });
+	if (!matchingAccount.empty())
+		return matchingAccount.release(matchingAccount.begin());
+	return nullptr;
+} //AccountDatabase::getAccount
+
+
 /*--------------------------------------------------------------------
 	Get all accounts
 
@@ -4,6 +4,10 @@
 #include "Active/File/Path.h"
 #include "Speckle/Record/Credentials/Account.h"

+namespace speckle::record::cred {
+	class Account;
+}
+
 namespace speckle::database {
 		
 	/*!
@@ -27,6 +31,13 @@ namespace speckle::database {
 		
 		// MARK: - Functions (const)
 		
+		/*!
+		 Get a specified account. NB: The server URL is provided as a fallback for the search if the specified accountID is not found
+		 @param accountID The account ID (the primary search field)
+		 @param serverURL The server URL (a fallback search field if the account ID does not exist)
+		 @return The requested account (nullptr on failure)
+		 */
+		std::unique_ptr<record::cred::Account> getAccount(const speckle::utility::String& accountID, const speckle::utility::String& serverURL) const;
 		/*!
 		 Get all accounts
 		 @return All the accounts
@@ -0,0 +1,127 @@
+#include "Speckle/Database/BIMElementDatabase.h"
+
+#include "Active/Database/Storage/Storage.h"
+#include "Active/Serialise/UnboxedTransport.h"
+#include "Speckle/Database/Identity/RecordID.h"
+#include "Speckle/Database/Storage/ArchicadDBase/Element/ArchicadElementDBaseEngine.h"
+#include "Speckle/Record/Element/Element.h"
+
+#include <array>
+
+using namespace active::container;
+using namespace active::database;
+using namespace active::event;
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::record;
+using namespace speckle::record::element;
+using namespace speckle::database;
+using namespace speckle::utility;
+
+namespace speckle::database {
+	
+	///Define other platform engines here as required
+#ifdef ARCHICAD
+	using ElementDatabaseEngine = ArchicadElementDBaseEngine;
+#endif
+
+		///Element database engine declaration
+	class BIMElementDatabase::Engine : public ElementDatabaseEngine {
+		using base = ArchicadElementDBaseEngine;
+		using base::base;
+	};
+
+		///Element database storage declaration
+	class BIMElementDatabase::Store : public Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID> {
+		using base = Storage<Element, UnboxedTransport, BIMRecordID, BIMRecordID, BIMRecordID, BIMRecordID>;
+		using base::base;
+	};
+	
+}
+
+namespace {
+	
+		///The database storage identifier for elements
+	const char* elementDBaseName = "speckle::database::BIMElementDatabase";
+		///The primary model table, e.g. floor plan in Archicad
+	const char* modelTableName = "Model";
+
+}
+
+/*--------------------------------------------------------------------
+	Constructor
+  --------------------------------------------------------------------*/
+BIMElementDatabase::BIMElementDatabase() {
+	m_engine = std::make_shared<Engine>(elementDBaseName,
+			//Schema
+		 DBaseSchema{active::utility::String{elementDBaseName},
+				//Tables
+			{
+					//Model element table
+				{
+					modelTableName, 0, 0, {}	//The primary model. Additonal tables could be linked to other drawings/layouts in future
+				}
+			}
+		}
+	);
+	m_store = std::make_shared<Store>(m_engine);
+} //BIMElementDatabase::BIMElementDatabase
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+BIMElementDatabase::~BIMElementDatabase() {}
+
+
+/*--------------------------------------------------------------------
+	Get the current user element selection
+ 
+	return: A list of selected element IDs
+  --------------------------------------------------------------------*/
+BIMLinkList BIMElementDatabase::getSelection() const {
+	return m_engine->getSelection();
+} //BIMElementDatabase::getSelection
+
+
+/*--------------------------------------------------------------------
+	Get a specified element
+ 
+	elementID: The ID of the target element
+ 
+	return: The requested element (nullptr on failure)
+  --------------------------------------------------------------------*/
+Element::Unique BIMElementDatabase::getElement(const BIMRecordID& elementID, std::optional<BIMRecordID> tableID,
+											   std::optional<BIMRecordID> documentID) const {
+	return m_engine->getObject(elementID, tableID, documentID);
+} //BIMElementDatabase::getElement
+
+
+/*--------------------------------------------------------------------
+	Get all elements
+ 
+	return: All the elements
+  --------------------------------------------------------------------*/
+Vector<Element> BIMElementDatabase::getElements() const {
+	return m_store->getObjects();
+} //BIMElementDatabase::getElements
+
+
+/*--------------------------------------------------------------------
+	Write an element to storage
+ 
+	element: The element to write
+  --------------------------------------------------------------------*/
+void BIMElementDatabase::write(const Element& element) const {
+	m_store->write(element);
+} //BIMElementDatabase::write
+
+
+/*--------------------------------------------------------------------
+	Erase an element
+ 
+	elementID: The ID of the element to erase
+  --------------------------------------------------------------------*/
+void BIMElementDatabase::erase(const Guid& elementID) const {
+	m_store->erase(elementID);
+} //BIMElementDatabase::erase
@@ -0,0 +1,80 @@
+#ifndef CONNECTOR_DATABASE_BIM_DATABASE
+#define CONNECTOR_DATABASE_BIM_DATABASE
+
+#include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Record/Element/Element.h"
+#include "Speckle/Utility/Guid.h"
+
+namespace active::event {
+	class Subscriber;
+}
+
+namespace speckle::database {
+	
+	/*!
+	 Database of model elements relating to a specific project
+	 */
+	class BIMElementDatabase {
+	public:
+
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 */
+		BIMElementDatabase();
+		BIMElementDatabase(const BIMElementDatabase&) = delete;
+		/*!
+		 Destructor
+		 */
+		~BIMElementDatabase();
+		
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the current user element selection
+		 @return A list of selected element IDs
+		 */
+		BIMLinkList getSelection() const;
+		/*!
+		 Get a specified element
+		 @param elementID The ID of the target element
+		 @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 element (nullptr on failure)
+		 */
+		record::element::Element::Unique getElement(const BIMRecordID& elementID, std::optional<BIMRecordID> tableID = std::nullopt,
+													std::optional<BIMRecordID> documentID = std::nullopt) const;
+		/*!
+		 Get a specified element
+		 @param link A link to the target element
+		 @return The requested element (nullptr on failure)
+		 */
+		record::element::Element::Unique getElement(const BIMLink& link) const { return getElement(link, link.tableID, link.docID); }
+		/*!
+		 Get all model elements
+		 @return All the elements
+		 */
+		active::container::Vector<record::element::Element> getElements() const;
+		/*!
+		 Write an element to storage
+		 @param element The element to write
+		 */
+		void write(const record::element::Element& element) const;
+		/*!
+		 Erase an element
+		 @param elementID The ID of the element to erase
+		 */
+		void erase(const speckle::utility::Guid& elementID) const;
+		
+	private:
+		class Engine;
+		class Store;
+			///Model element database storage
+		std::shared_ptr<Engine> m_engine;
+		std::shared_ptr<Store> m_store;
+	};
+
+}
+
+#endif	//CONNECTOR_DATABASE_BIM_DATABASE
@@ -0,0 +1,24 @@
+#include "Speckle/Database/Content/Record.h"
+
+#include "Speckle/Utility/Guid.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::utility;
+
+/*--------------------------------------------------------------------
+	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 Record::fillInventory(active::serialise::Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ Identity{"id"}, active::database::record::FieldIndex::idIndex, element },
+		},
+	}.withType(&typeid(base)));
+	return true;
+} //Record::fillInventory
@@ -0,0 +1,62 @@
+#ifndef SPECKLE_DATABASE_RECORD
+#define SPECKLE_DATABASE_RECORD
+
+#include "Active/Database/Content/Record.h"
+#include "Speckle/Database/Identity/Link.h"
+#include "Speckle/Database/Identity/BIMRecordID.h"
+
+namespace speckle::database {
+
+	/*!
+	 Base class for a database record
+	 */
+	class BIMRecord : public active::database::BIMRecord<BIMRecordID> {
+	public:
+
+		// MARK: - Types
+		
+		using base = active::database::BIMRecord<BIMRecordID>;
+			///Unique pointer
+		using Unique = std::unique_ptr<BIMRecord>;
+			///Shared pointer
+		using Shared = std::shared_ptr<BIMRecord>;
+			///Optional
+		using Option = std::optional<BIMRecord>;
+
+		// MARK: - Constructors
+		
+		/*!
+		 Default constructor
+		 */
+		BIMRecord() : base{active::utility::Guid{true}.operator active::utility::String(),
+				active::utility::Guid{true}.operator active::utility::String()} {}	//TODO: Implement a better default for the ID
+		/*!
+		 Constructor
+		 @param ID The record ID
+		 */
+		BIMRecord(speckle::utility::String ID, speckle::utility::String::Option globID = std::nullopt) :
+				base{ID, globID.value_or(active::utility::Guid{true}.operator active::utility::String())} {}
+		/*!
+		 Destructor
+		 */
+		virtual ~BIMRecord() {}
+		
+		// MARK: - Functions (const)
+
+		
+		// MARK: - Functions (mutating)
+
+		
+		// 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;
+	};
+	
+}
+
+#endif	//SPECKLE_DATABASE_RECORD
@@ -0,0 +1,37 @@
+#ifndef SPECKLE_DATABASE_BIM_INDEX
+#define SPECKLE_DATABASE_BIM_INDEX
+
+#include "Active/Database/Identity/Index.h"
+#include "Speckle/Database/Identity/RecordID.h"
+
+namespace speckle::database {
+	
+	/*!
+	 Record index class
+	 
+	 A record index is the information required to uniquely identify (and locate) a specified record in some database/app context. For Archicad,
+	 this is typically a guid, for Revit a string and for Vectorworks a handle. Note that this index is not necessarily persistent between
+	 sessions.
+	 */
+	class BIMIndex : public active::database::Index<BIMRecordID> {
+	public:
+
+		// MARK: - Types
+		
+		using base = active::database::Index<BIMRecordID>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		// MARK: - Public variables
+		
+			//The table identifier
+		BIMTableID table;
+			//The document identifier
+		BIMDocID document;
+	};
+	
+}
+
+#endif	//SPECKLE_DATABASE_BIM_INDEX
@@ -1,5 +1,4 @@
-#include "Speckle/Database/Identity/Link.h"
-#include "Speckle/Utility/Guid.h"
+#include "Speckle/Database/Identity/BIMLink.h"

 using namespace speckle::database;
 using namespace speckle::utility;
@@ -10,9 +9,9 @@ using namespace speckle::utility;
 
 	selected: Information about a selected Archicad element
  --------------------------------------------------------------------*/
-//Link::Link(const API_Neig& selected) : base{Guid{selected.guid}} {
-	//More info should be extracted from API_Neig in future (as required)
-//} //Link::Link
+BIMLink::BIMLink(const API_Neig& selected) : base{Guid{selected.guid}} {
+	//More info should be extracted from API_Neig in future (as required) - extract into link settings, e.g. selection target etc
+} //Link::Link
 #endif


@@ -0,0 +1,47 @@
+#ifndef SPECKLE_DATABASE_BIM_LINK
+#define SPECKLE_DATABASE_BIM_LINK
+
+#include "Active/Setting/SettingList.h"
+#include "Active/Database/Identity/Link.h"
+#include "Speckle/Database/Identity/BIMRecordID.h"
+
+namespace speckle::database {
+
+	/*!
+	 Record link class, binding an index to additional information
+	 
+	 The essential part of a link is the index pointing to a target record. In some cases, e.g. where the user has selected something in a rendered
+	 scene, the index is to a proxy object that represents another record in a specific context, e.g. a 2D representation of a 3D element rendered
+	 in a cut plance section view. A tool working with the link might be interested in either the proxy or the original - passing a link allows
+	 this distinction to be easily made.
+	 
+	 A link may optionally carry any number of settings. In the context of a user selection (for example) there might be settings describing where
+	 the user made the selection (e.g. the hole in a floor slab), allowing a tool working on that selection to be more precise.
+	 */
+	class BIMLink : public active::database::Link<BIMRecordID> {
+	public:
+		
+		// MARK: - Types
+		
+		using base = active::database::Link<BIMRecordID>;
+		
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		BIMLink() = default;
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param selected Information about a selected Archicad element
+		 */
+		BIMLink(const API_Neig& selected);
+#endif
+	};
+	
+		//A list of links to BIM records
+	using BIMLinkList = std::vector<BIMLink>;
+
+}
+
+#endif	//SPECKLE_DATABASE_BIM_LINK
@@ -0,0 +1,24 @@
+#ifndef SPECKLE_DATABASE_BIM_ID
+#define SPECKLE_DATABASE_BIM_ID
+
+#include "Speckle/Utility/Guid.h"
+
+namespace speckle::database {
+	
+#ifdef ARCHICAD
+		//Common BIM record identifier type (e.g. to BIM elements)
+	using BIMRecordID = speckle::utility::Guid;
+		//Common BIM table identifier type (e.g. primary model, views)
+	using BIMTableID = speckle::utility::Guid;
+		//Common BIM document identifier type (e.g. BIM drawing identifier, e.g. section, layout etc)
+	using BIMDocID = speckle::utility::Guid;
+		//Common BIM database identifier type (e.g. model database, library database, attribute database)
+	using BIMDBaseID = speckle::utility::Guid;
+#endif
+
+		//A list of BIM record IDs
+	using BIMRecordIDList = std::vector<BIMRecordID>;
+	
+}
+
+#endif	//SPECKLE_DATABASE_BIM_ID
@@ -1,11 +1,8 @@
 #ifndef SPECKLE_DATABASE_INDEX
 #define SPECKLE_DATABASE_INDEX

-#include "Active/Database/Identity/Link.h"
+#include "Active/Database/Identity/Index.h"
 #include "Speckle/Database/Identity/RecordID.h"
-#include "Speckle/Utility/String.h"
-
-#include <any>

 namespace speckle::database {
 	
@@ -2,6 +2,7 @@
 #define SPECKLE_DATABASE_LINK

 #include "Active/Setting/SettingList.h"
+#include "Active/Database/Identity/Link.h"
 #include "Speckle/Database/Identity/Index.h"

 namespace speckle::database {
@@ -29,13 +30,6 @@ namespace speckle::database {
 		using base::base;
 		
 		Link() = default;
-#ifdef ARCHICAD
-		/*!
-		 Constructor
-		 @param selected Information about a selected Archicad element
-		 */
-		Link(const API_Neig& selected);
-#endif
 	};
 	
 }
@@ -0,0 +1,95 @@
+#include "Speckle/Database/Storage/ArchicadDBase/ArchicadDBaseCore.h"
+
+#ifdef ARCHICAD
+
+#include "Active/Utility/Defer.h"
+#include "Active/Utility/Memory.h"
+#include "Active/Utility/String.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Environment/Project.h"
+#include "Speckle/Event/Type/DocStoreMergeEvent.h"
+#include "Speckle/Event/Type/ProjectEvent.h"
+#include "Speckle/Utility/Guid.h"
+#include "Speckle/Utility/String.h"
+
+#include <ACAPinc.h>
+#include <BM.hpp>
+
+using namespace active::event;
+using namespace active::setting;
+using namespace speckle::database;
+using namespace speckle::environment;
+using namespace speckle::event;
+using namespace speckle::utility;
+
+using enum ArchicadDBaseCore::Status;
+
+namespace {
+	
+	/*--------------------------------------------------------------------
+		Convert an Archicad API error code to a ArchicadDBaseCore status
+	 
+		acErrorCode: The API error code
+	 
+		return: An equivalent status code
+	 --------------------------------------------------------------------*/
+	ArchicadDBaseCore::Status convertArchicadError(long acErrorCode) {
+		using enum ArchicadDBaseCore::Status;
+		switch (acErrorCode) {
+			case NoError:
+				return nominal;
+			case APIERR_BADPARS:
+				return badParameter;
+			case APIERR_BADID:
+				return badID;
+			default:
+				break;
+		}
+		return error;
+	} //convertArchicadError
+
+
+		///Category for ArchicadElementDBase processing errors
+	class ArchicadDBaseCategory : public std::error_category {
+	public:
+			///Category name
+		const char* name() const noexcept override {
+			return "speckle::database::archicad::category";
+		}
+		/*!
+			Get a message for a specified error code
+			@param errorCode A ArchicadElementDBase processing code
+			@return The error message for the specified code
+		*/
+		std::string message(int errorCode) const override {
+				//TODO: These error messages are ok for developers - but can we help users more?
+			switch (static_cast<ArchicadDBaseCore::Status>(errorCode)) {
+				case nominal:
+					return "";
+				case badParameter:
+					return "An internal function has been incorrectly used";
+				case badID:
+					return "Internal data has been requested using an invalid identity";
+				case error:
+					return "A non-specific error occurred";
+				default:
+					return "An unknown error occurred";
+			}
+		}
+	};
+
+		///ArchicadElementDBase processing category error instance
+	static ArchicadDBaseCategory instance;
+	
+}
+
+/*--------------------------------------------------------------------
+	Make an error code for ArchicadElementDBase processing
+ 
+	return: An STL error code
+ --------------------------------------------------------------------*/
+std::error_code ArchicadDBaseCore::makeError(ArchicadDBaseCore::Status code) {
+	return std::error_code(static_cast<int>(code), instance);
+} //ArchicadDBaseCore::makeError
+
+#endif
@@ -0,0 +1,86 @@
+#ifndef SPECKLE_DATABASE_ARCHICAD_DBASE_CORE
+#define SPECKLE_DATABASE_ARCHICAD_DBASE_CORE
+
+#ifdef ARCHICAD
+
+#include "Active/File/Path.h"
+#include "Active/Setting/SettingList.h"
+#include "Active/Database/Storage/DBaseSchema.h"
+#include "Active/Utility/NameID.h"
+#include "Speckle/Event/Subscriber/DocStoreSubscriber.h"
+#include "Speckle/Event/Subscriber/ProjectSubscriber.h"
+
+namespace speckle::database {
+	
+	using ArchicadDBaseSchema = active::database::DBaseSchema<>;
+
+	/*!
+	 Core functionality and definitions for a mechanism to store data in a BIM (3rd-party) document/database
+	 
+	 Currently implement for Archicad Add-On Objects
+	 */
+	class ArchicadDBaseCore  {
+	public:
+
+		// MARK: - Types
+		
+			///Status of of the ArchicadElementDBase database
+		enum class Status {
+			nominal,	///<No errors logged
+			badParameter,	///<The data supplied to an SDK function call was invalid
+			badID,	///<The ID for the stored data is invalid
+			error,	///<An unidentified error occurred
+		};
+		
+		// MARK: - Static functions
+		
+		/*!
+		 Make an error code for ArchicadElementDBase processing
+		 @return An STL error code
+		 */
+		static std::error_code makeError(ArchicadDBaseCore::Status code);
+
+		// MARK: - Constructors
+		
+		/*!
+		 Default constructor
+		 @param id The document storage identifier
+		 @param schema The document storage schema
+		 */
+		ArchicadDBaseCore(const active::utility::NameID& id, ArchicadDBaseSchema&& schema) : m_id(id), m_schema{schema} {}
+		ArchicadDBaseCore(const ArchicadDBaseCore&) = default;
+		/*!
+		 Destructor
+		 */
+		virtual ~ArchicadDBaseCore() {}
+		
+		// MARK: - Function (const)
+		
+		/*!
+		 Get the database schema
+		 @return The database schema
+		 */
+		const ArchicadDBaseSchema& getSchema() const { return m_schema; }
+		/*!
+		 Get the database id
+		 @return The database id
+		 */
+		const active::utility::NameID& getID() const { return m_id; }
+		
+		// MARK: - Functions (mutating)
+		
+	protected:
+
+		
+	private:
+			///The database schema
+		ArchicadDBaseSchema m_schema;
+			///The database ID (mutable to allow lazy loading when data is accessed)
+		mutable active::utility::NameID m_id;
+	};
+	
+}
+
+#endif	//ARCHICAD
+
+#endif	//SPECKLE_DATABASE_ARCHICAD_DBASE_CORE
@@ -0,0 +1,223 @@
+#include "Speckle/Database/Storage/ArchicadDBase/Element/ArchicadElementDBaseEngine.h"
+
+#ifdef ARCHICAD
+
+#include "Active/Utility/Defer.h"
+#include "Active/Utility/Memory.h"
+#include "Active/Utility/String.h"
+#include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Environment/Addon.h"
+#include "Speckle/Environment/Project.h"
+#include "Speckle/Event/Type/DocStoreMergeEvent.h"
+#include "Speckle/Event/Type/ProjectEvent.h"
+#include "Speckle/Utility/Guid.h"
+#include "Speckle/Utility/String.h"
+
+#include <ACAPinc.h>
+#include <ACAPI_Database.h>
+#include <BM.hpp>
+
+using namespace active::event;
+using namespace active::setting;
+using namespace speckle::database;
+using namespace speckle::environment;
+using namespace speckle::event;
+using namespace speckle::record::element;
+using namespace speckle::utility;
+
+using enum ArchicadDBaseCore::Status;
+
+namespace {
+	
+	/*!
+	 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;
+		dbaseInfo.databaseUnId.elemSetId = tableID;
+		if (auto err = ACAPI_Window_GetDatabaseInfo(&dbaseInfo); err == NoError)
+			return dbaseInfo;
+		return std::nullopt;
+	} //getTableInfo
+
+	
+	/*!
+	 Get the ID of the active Archicad table
+	 @return The active table ID (nullopt on failure)
+	 */
+	std::optional<BIMRecordID> getActiveTable() {
+		API_WindowInfo dbaseInfo;
+		active::utility::Memory::erase(dbaseInfo);
+		if (auto err = ACAPI_Database_GetCurrentDatabase(&dbaseInfo); err == NoError)
+			return dbaseInfo.databaseUnId.elemSetId;
+		return std::nullopt;
+	} //getActiveTable
+
+	
+	/*!
+	 Set the active Archicad table
+	 @param tableID The target table ID
+	 @return True on success
+	 */
+	bool setActiveTable(const BIMRecordID& tableID) {
+		if (!tableID)
+			return false;	//Null guid doens't point to anything
+		if (auto activeTable = getActiveTable(); activeTable && *activeTable == tableID)
+			return true;
+		auto dbaseInfo = getTableInfo(tableID);
+		if (!dbaseInfo)
+			return false;
+		return ACAPI_Database_ChangeCurrentDatabase(&*dbaseInfo) == NoError;
+	} //setActiveTable
+	
+	
+	/*!
+	 Make a new element object
+	 @param elementData The API element representation
+	 @return A new element object (nullptr on failure)
+	 */
+	Element::Unique makeElement(const API_Element& elementData) {
+			//Implement an object factory in future as classes for specific element types are implemented, e.g. Wall, Roof etc. using hash map
+			//The fallback for undefined element types will always be the base Element class
+		return std::make_unique<Element>(elementData);
+	}
+
+}
+
+/*--------------------------------------------------------------------
+	Get the current user element selection
+ 
+	return: A list of selected element IDs
+  --------------------------------------------------------------------*/
+BIMLinkList ArchicadElementDBaseEngine::getSelection() const {
+	BIMLinkList result;
+	API_SelectionInfo selectionInfo;
+	active::utility::Memory::erase(selectionInfo);
+	GS::Array<API_Neig> selection;
+	if (auto err = ACAPI_Selection_Get(&selectionInfo, &selection, true); err == NoError) {
+		for (const auto& item : selection)
+			result.push_back(BIMLink{item});
+	}
+	return result;
+} //ArchicadElementDBaseEngine::getSelection
+
+
+/*--------------------------------------------------------------------
+	Get an object by index
+ 
+	index: The object index
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+ 
+	return: The requested object (nullptr on failure)
+  --------------------------------------------------------------------*/
+std::unique_ptr<Element> ArchicadElementDBaseEngine::getObject(const BIMRecordID& ID, std::optional<BIMRecordID> tableID,
+															   std::optional<BIMRecordID> documentID)  const {
+	API_Element element;
+	active::utility::Memory::erase(element);
+	API_Guid guid{ID.operator API_Guid()};
+	if (ACAPI_Element_GetElementFromAnywhere(&guid, &element) != NoError)
+		return nullptr;
+	return makeElement(element);
+} //ArchicadElementDBaseEngine::getObject
+
+
+/*--------------------------------------------------------------------
+	Get an object in a transportable form, e.g. packaged for serialisation
+ 
+	index: The object index
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+ 
+	return: The requested wrapped cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+active::serialise::Cargo::Unique ArchicadElementDBaseEngine::getObjectCargo(const BIMRecordID& ID, std::optional<BIMRecordID> tableID,
+																		   std::optional<BIMRecordID> documentID)  const {
+	return nullptr; //TODO: Implement
+} //ArchicadElementDBaseEngine::getObject
+
+
+/*--------------------------------------------------------------------
+	Get all objects
+ 
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+ 
+	return: The requested objects (nullptr on failure)
+  --------------------------------------------------------------------*/
+active::container::Vector<Element> ArchicadElementDBaseEngine::getObjects(std::optional<BIMRecordID> tableID,
+																					  std::optional<BIMRecordID> documentID) const {
+	if (tableID)
+		setActiveTable(*tableID);
+	return {}; //TODO: Implement
+} //ArchicadElementDBaseEngine::getObjects
+
+
+/*--------------------------------------------------------------------
+	Get all objects
+ 
+	filter: The object filter
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+ 
+	return: The requested objects (nullptr on failure)
+  --------------------------------------------------------------------*/
+active::container::Vector<Element> ArchicadElementDBaseEngine::getObjects(const Filter& filter, std::optional<BIMRecordID> tableID,
+																					  std::optional<BIMRecordID> documentID) const {
+	return {};
+} //ArchicadElementDBaseEngine::getObjects
+
+
+/*--------------------------------------------------------------------
+	Write an object to the database
+ 
+	object: The object to write
+	objID: The object ID
+	objDocID: The object document-specific ID (unique within a specific document - nullopt if not document-bound)
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+  --------------------------------------------------------------------*/
+void ArchicadElementDBaseEngine::write(const Element& object, const BIMRecordID& objID, std::optional<BIMRecordID> objDocID,
+																   std::optional<BIMRecordID> tableID, std::optional<BIMRecordID> documentID) const {
+	
+} //ArchicadElementDBaseEngine::write
+
+
+/*--------------------------------------------------------------------
+	Erase an object by index
+ 
+	objID: The object ID
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (when the object is bound to a specific document)
+ 
+	return: True if the object was successfully erased
+  --------------------------------------------------------------------*/
+void ArchicadElementDBaseEngine::erase(const BIMRecordID& ID, std::optional<BIMRecordID> tableID,
+													   std::optional<BIMRecordID> documentID) const {
+
+} //ArchicadElementDBaseEngine::erase
+
+
+/*--------------------------------------------------------------------
+	Erase all objects
+ 
+	tableID: Optional table ID (defaults to the floor plan)
+	documentID: Optional document ID (filter for this document only - nullopt = all objects)
+  --------------------------------------------------------------------*/
+void ArchicadElementDBaseEngine::erase(std::optional<BIMRecordID> tableID, std::optional<BIMRecordID> documentID) const {
+
+} //ArchicadElementDBaseEngine::erase
+
+
+/*--------------------------------------------------------------------
+	Get the database outline
+ 
+	return: The database outline
+  --------------------------------------------------------------------*/
+ArchicadElementDBaseEngine::Outline ArchicadElementDBaseEngine::getOutline() const {
+	return {};
+} //ArchicadElementDBaseEngine::getOutline
+
+#endif
@@ -0,0 +1,117 @@
+#ifndef SPECKLE_DATABASE_ARCHICAD_ELEMENT_DBASE_ENGINE
+#define SPECKLE_DATABASE_ARCHICAD_ELEMENT_DBASE_ENGINE
+
+#include "Active/Database/Storage/DBaseEngine.h"
+#include "Active/Serialise/UnboxedTransport.h"
+#include "Speckle/Database/Storage/ArchicadDBase/ArchicadDBaseCore.h"
+#include "Speckle/Database/Identity/BIMLink.h"
+#include "Speckle/Record/Element/Element.h"
+#include "Speckle/Utility/Guid.h"
+#include "Speckle/Utility/String.h"
+
+#include <algorithm>
+#include <ranges>
+
+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 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 = base::Filter;
+		using Outline = base::Outline;
+		
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param id The document storage identifier
+		 */
+		ArchicadElementDBaseEngine(const active::utility::NameID& id, ArchicadDBaseSchema&& schema) : ArchicadDBaseCore{id, std::move(schema)} {}
+		ArchicadElementDBaseEngine(const ArchicadElementDBaseEngine&) = delete;
+		
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the current user element selection
+		 @return A list of selected element IDs
+		 */
+		BIMLinkList getSelection() const;
+		/*!
+		 Get an object by index
+		 @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 object (nullptr on failure)
+		 */
+		std::unique_ptr<Element> getObject(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get an object in a transportable form, e.g. packaged for serialisation
+		 @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)
+		 */
+		active::serialise::Cargo::Unique getObjectCargo(const BIMRecordID& objID, std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get all objects
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return The requested objects (nullptr on failure)
+		 */
+		active::container::Vector<Element> getObjects(std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get a filtered list of objects
+		 @param filter The object filter
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (filter for this document only - nullopt = all objects)
+		 @return The filtered objects (nullptr on failure)
+		 */
+		active::container::Vector<Element> getObjects(const Filter& filter, std::optional<BIMRecordID> tableID = std::nullopt,
+												  std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Write an object to the database
+		 @param object The object to write
+		 @param objID The object ID
+		 @param objDocID The object document-specific ID (unique within a specific document - nullopt if not document-bound)
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 */
+		void write(const Element& object, const BIMRecordID& objID, std::optional<BIMRecordID> objDocID = std::nullopt,
+				   std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Erase an object by index
+		 @param ID 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)
+		 @throw Exception thrown on SQL error
+		 */
+		void erase(const BIMRecordID& ID, std::optional<BIMRecordID> tableID = std::nullopt,
+				   std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Erase all objects
+		 @param tableID Optional table ID (defaults to the floor plan)
+		 @param documentID Optional document ID (when the object is bound to a specific document)
+		 @throw Exception thrown on SQL error
+		 */
+		void erase(std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt) const override;
+		/*!
+		 Get the database outline
+		 @return The database outline
+		 */
+		Outline getOutline() const override;
+				
+	private:
+		void setTable(std::optional<BIMRecordID> tableID = std::nullopt, std::optional<BIMRecordID> documentID = std::nullopt);
+	};
+	
+}
+
+#endif	//SPECKLE_DATABASE_ARCHICAD_ELEMENT_DBASE_ENGINE
@@ -105,7 +105,7 @@ namespace {
 	public:
 			///Category name
 		const char* name() const noexcept override {
-			return "active::database::sqlite::category";
+			return "speckle::database::docStore::category";
 		}
 		/*!
 			Get a message for a specified error code
@@ -122,6 +122,11 @@ namespace speckle::database {
 		 @return The database outline
 		 */
 		Outline getOutline() const override;
+		/*!
+		 Get the engine unique ID
+		 @return The unique ID
+		 */
+		RecordID getUniqueID() const { return getCache()->getID(); }
 		
 	protected:
 		/*!
@@ -1,5 +1,6 @@
 #include "Speckle/Environment/Project.h"

+#include "Speckle/Database/BIMElementDatabase.h"
 #include "Speckle/Environment/Addon.h"
 #include "Speckle/SpeckleResource.h"

@@ -7,6 +8,7 @@
 #include <ACAPinc.h>
 #endif

+using namespace speckle::database;
 using namespace speckle::environment;
 using namespace speckle::utility;

@@ -20,6 +22,7 @@ namespace {
 	identity: Optional name/ID for the subscriber
  --------------------------------------------------------------------*/
 Project::Project() {
+	m_element = std::make_unique<BIMElementDatabase>();
 } //Project::Project


@@ -4,6 +4,10 @@
 #include "Active/File/Path.h"
 #include "Speckle/Utility/String.h"

+namespace speckle::database {
+	class BIMElementDatabase;
+}
+
 namespace speckle::environment {
 	
 	class Addon;
@@ -50,6 +54,11 @@ namespace speckle::environment {
 		 @return Project information
 		 */
 		Info getInfo() const;
+		/*!
+		 Get the account database
+		 @return The account database
+		 */
+		const database::BIMElementDatabase* getElementDatabase() const { return m_element.get(); }
 		
 		// MARK: - Functions (mutating)
 		
@@ -62,6 +71,9 @@ namespace speckle::environment {
 		 NB: Only the Addon class can create projects. Clients can get the active project from the running add-on.
 		 */
 		Project();
+		
+	private:
+		std::unique_ptr<database::BIMElementDatabase> m_element;
 	};

 }
@@ -1,7 +1,7 @@
 #include "Speckle/Event/Subscriber/SelectionSubscriber.h"

 #include "Speckle/Environment/Addon.h"
-#include "Speckle/Database/Identity/Link.h"
+#include "Speckle/Database/Identity/BIMLink.h"
 #include "Speckle/Event/Type/SelectionEvent.h"

 #ifdef ARCHICAD
@@ -23,7 +23,7 @@ namespace {
 	 */
 	GSErrCode __ACENV_CALL selectionCallback(const API_Neig* params) {
 		if (addon() != nullptr) {
-			auto selection = (params == nullptr) ? Link{} : Link{*params};
+			auto selection = (params == nullptr) ? BIMLink{} : BIMLink{*params};
 			addon()->publishExternal(SelectionEvent{selection});
 		}
 		return NoError;
@@ -5,7 +5,7 @@

 #include "Active/Utility/Guid.h"
 #include "Active/Utility/String.h"
-#include "Speckle/Database/Identity/Link.h"
+#include "Speckle/Database/Identity/BIMLink.h"

 namespace speckle::event {
 	
@@ -24,7 +24,7 @@ namespace speckle::event {
 		 Constructor
 		 @param selected A link to a selected element (nullopt if the selection is empty)
 		 */
-		SelectionEvent(speckle::database::Link::Option selected) : m_selectedLink{selected} {}
+		SelectionEvent(speckle::database::BIMLink::Option selected) : m_selectedLink{selected} {}
 		/*!
 		 Copy constructor
 		 @param source The object to copy
@@ -46,10 +46,10 @@ namespace speckle::event {
 		 Get a link to the last selected element
 		 @return A link to the last selected element (nullopt if the event selection is empty)
 		 */
-		speckle::database::Link::Option getLastSelected() const { return m_selectedLink; }
+		speckle::database::BIMLink::Option getLastSelected() const { return m_selectedLink; }

 	private:
-		speckle::database::Link::Option m_selectedLink;
+		speckle::database::BIMLink::Option m_selectedLink;
 	};
 	
 }
@@ -0,0 +1,65 @@
+#include "Speckle/Primitive/Mesh/Mesh.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Inventory/Identity.h"
+
+#include <array>
+
+using namespace active::serialise;
+using namespace speckle::primitive;
+
+namespace {
+
+		///Serialisation fields
+	enum FieldIndex {
+		vertexID,
+		faceID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"vertices"},
+		Identity{"faces"},
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	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;
+	inventory.merge(Inventory{
+		{
+			//{ fieldID[vertexID], vertexID, vertices::size(), std::nullopt, !vertices::empty() },
+			//{ fieldID[elementID], elementID, faces::size(), std::nullopt, !faces::empty() },
+		},
+	}.withType(&typeid(Mesh)));
+	return true;
+} //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 {
+	if (item.ownerType != &typeid(Mesh))
+		return nullptr;
+	using namespace active::serialise;
+	switch (item.index) {
+		case vertexID:
+			return nullptr;	//TODO: Implement vertices array
+		case faceID:
+			return nullptr;	//TODO: Implement faces array
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //Mesh::getCargo
@@ -0,0 +1,45 @@
+#ifndef SPECKLE_PRIMITIVE_MESH
+#define SPECKLE_PRIMITIVE_MESH
+
+#include "Active/Serialise/Package/Package.h"
+
+namespace speckle::primitive {
+	
+	/*!
+	 Class for a 3D mesh
+	*/
+	class Mesh : public active::serialise::Package {
+	public:
+
+		// MARK: - Constructors
+		
+		/*!
+		 Default constructor
+		 */
+		Mesh() {}
+
+		// MARK: - Functions (const)
+		
+		
+		// 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)
+		*/
+		active::serialise::Cargo::Unique getCargo(const active::serialise::Inventory::Item& item) const override;
+		
+	private:
+		
+	};
+	
+}
+
+#endif	//SPECKLE_PRIMITIVE_MESH
@@ -48,6 +48,17 @@ namespace speckle::record::cred {

 		// MARK: - Functions (const)
 		
+		/*!
+		 Get the account server URL
+		 @return The account server URL (nullopt if none specified)
+		 */
+		speckle::utility::String getServerURL() const { return m_serverInfo.getURL(); }
+		/*!
+		 Get the account token
+		 @return The account token
+		 */
+		speckle::utility::String getToken() const { return m_token; }
+		
 		// MARK: - Functions (mutating)
 		
 		// MARK: - Serialisation
@@ -89,7 +89,7 @@ Cargo::Unique ServerInfo::getCargo(const Inventory::Item& item) const {
 		case frontEndID:
 			return std::make_unique<ValueWrap<bool>>(m_frontend2);
 		case urlID:
-			return std::make_unique<StringOptWrap>(m_url);
+			return std::make_unique<StringWrap>(m_url);
 		case migrationID:
 			return std::make_unique<Mover>(PackageUniqueWrap{m_migration});
 		default:
@@ -32,7 +32,7 @@ namespace speckle::record::cred {
 		 */
 		ServerInfo(const utility::String& name, const utility::String::Option company = std::nullopt,
 				   const utility::String::Option version = std::nullopt, const utility::String::Option contact = std::nullopt,
-				   const utility::String::Option description = std::nullopt, const utility::String::Option url = std::nullopt,
+				   const utility::String::Option description = std::nullopt, const utility::String url = {},
 				   bool isFrontEnd = false, std::unique_ptr<ServerMigration> migration = nullptr) :
 				m_name{name}, m_company{company}, m_version{version}, m_adminContact{contact}, m_description{description},
 				m_url{url}, m_frontend2{isFrontEnd}, m_migration{std::move(migration)} {}
@@ -90,7 +90,7 @@ namespace speckle::record::cred {
 		 Get the URL
 		 @return The URL
 		 */
-		const utility::String::Option& getURL() const { return m_url; }
+		const utility::String& getURL() const { return m_url; }
 		/*!
 		 Get the migration history
 		 @return The migration history (nullptr = no history)
@@ -143,7 +143,7 @@ namespace speckle::record::cred {
 		 This field is not returned from the GQL API, it should be populated after construction.
 		 See "Speckle.Core.Credentials.AccountManager"
 		 */
-		utility::String::Option m_url;
+		utility::String m_url;
 			///Server migration record
 		std::unique_ptr<ServerMigration> m_migration;
 	};
@@ -0,0 +1,141 @@
+#include "Speckle/Record/Element/Element.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Serialise/Package/Wrapper/PackageWrap.h"
+#include "Speckle/Primitive/Mesh/Mesh.h"
+#include "Speckle/Utility/Guid.h"
+
+using namespace active::serialise;
+using namespace speckle::record::element;
+using namespace speckle::utility;
+
+#include <array>
+
+namespace speckle::record::element {
+	
+	class Element::Data {
+	public:
+		friend class Element;
+		
+		Data(const API_Element& elem) : root{std::make_unique<API_Element>(elem)} {}
+		Data(const Data& source) : root{std::make_unique<API_Element>(*source.root)} {}
+		
+	private:
+		std::unique_ptr<API_Element> root;
+		std::unique_ptr<Element::Body> m_cache;
+	};
+	
+}
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		bodyID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"displayValue"},
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+Element::Element() {
+} //Element::Element
+
+
+/*--------------------------------------------------------------------
+	Constructor
+ 
+	elemData: Archicad element data
+  --------------------------------------------------------------------*/
+Element::Element(const API_Element& elemData) {
+	m_data = std::make_unique<Data>(elemData);
+} //Element::Element
+
+
+/*--------------------------------------------------------------------
+	Copy constructor
+ 
+ 	source: The object to copy
+  --------------------------------------------------------------------*/
+Element::Element(const Element& source) {
+	m_data = source.m_data ? std::make_unique<Data>(*m_data) : nullptr;
+} //Element::Element
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+Element::~Element() {}
+
+
+/*--------------------------------------------------------------------
+	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& Element::getHead() const {
+	return m_data->root->header;
+} //Element::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& Element::getHead() {
+	return m_data->root->header;
+} //Element::getHead
+
+
+/*--------------------------------------------------------------------
+	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 Element::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	auto body = getBody();
+	inventory.merge(Inventory{
+		{
+			{ fieldID[bodyID], bodyID, body == nullptr ? 0 : static_cast<uint32_t>(body->size()) },	//TODO: implement other fields
+		},
+	}.withType(&typeid(Element)));
+	return base::fillInventory(inventory);
+} //Element::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	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 bodyID:
+			return nullptr;	//TODO: implement
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //Element::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void Element::setDefault() {
+	base::setDefault();
+	m_data.reset();
+} //Element::setDefault
@@ -0,0 +1,116 @@
+#ifndef SPECKLE_RECORD_ELEMENT
+#define SPECKLE_RECORD_ELEMENT
+
+#include "Speckle/Database/Content/Record.h"
+#include "Speckle/Utility/String.h"
+
+namespace speckle::primitive {
+	class Mesh;
+}
+
+namespace speckle::record::element {
+	
+	/*!
+	 Base BIM element class
+	 */
+	class Element : public speckle::database::Record {
+	public:
+		
+			///An element 3D body primitive
+		using Body = std::vector<primitive::Mesh>;
+
+		// MARK: - Types
+		
+		using base = speckle::database::Record;
+			///Unique pointer
+		using Unique = std::unique_ptr<Element>;
+			///Shared pointer
+		using Shared = std::shared_ptr<Element>;
+			///Optional
+		using Option = std::optional<Element>;
+
+		// MARK: - Constructors
+		
+		using base::base;
+		
+		/*!
+		 Default constructor
+		 */
+		Element();
+#ifdef ARCHICAD
+		/*!
+		 Constructor
+		 @param elemData Archicad element data
+		 */
+		Element(const API_Element& elemData);
+#endif
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		Element(const Element& source);
+		/*!
+		 Destructor
+		 */
+		~Element();
+
+		/*!
+			Object cloning
+			@return A clone of this object
+		*/
+		Element* clonePtr() const override { return new Element{*this}; }
+
+
+		// MARK: - Functions (const)
+
+		/*!
+			Get the element body
+			@return An array of meshes from the element body (nullptr if no body data is available)
+		*/
+		virtual Body* getBody() const { return nullptr; }
+#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)
+		*/
+		virtual const API_Elem_Head& getHead() const;
+#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)
+		*/
+		virtual API_Elem_Head& getHead();
+#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 element data
+		std::unique_ptr<Data> m_data;
+	};
+
+}
+
+#endif	//SPECKLE_RECORD_ELEMENT
@@ -0,0 +1,90 @@
+#include "Speckle/Serialise/Detached/DetachedReference.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Speckle/Serialise/Detached/DetachmentManager.h"
+#include "Speckle/Utility/String.h"
+
+using namespace active::serialise;
+using namespace speckle::serialise;
+using namespace speckle::utility;
+
+#include <array>
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		refdID,
+		speckTypeID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"referencedId"},
+		Identity{"speckle_type"},
+	};
+	
+		///Type signature for a reference to a detached object
+	String referenceType{"reference"};
+
+}
+
+/*--------------------------------------------------------------------
+	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 DetachedReference::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[refdID], refdID, element },
+			{ fieldID[speckTypeID], speckTypeID, element },
+		},
+	}.withType(&typeid(DetachedReference)));
+	return true;
+} //DetachedReference::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique DetachedReference::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(DetachedReference))
+		return base::get().getCargo(item);
+	using namespace active::serialise;
+	switch (item.index) {
+		case refdID: {
+				//If we don't have an allocated string for receiving a reference (from 'setDefault') then we need to create one
+			if (!m_reference) {
+					//Ask a manager to send the detached data and provide a reference
+				auto detachmentManager = getManager<DetachmentManager>();
+				if (detachmentManager == nullptr)
+					return nullptr;	//TODO: Discuss if this is a serious error - possibly throwing an exception is warranted
+				m_reference = detachmentManager->send(std::forward<Package&&>(base::get()), item.identity());
+				if (!m_reference)
+					throw; //TODO: Throw a more descriptive exception
+			}
+			std::make_unique<StringWrap>(*m_reference);
+		}
+		case speckTypeID:
+			return std::make_unique<StringWrap>(m_type);
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //DetachedReference::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void DetachedReference::setDefault() {
+	m_type.clear();
+	m_reference = String{};
+} //DetachedReference::setDefault
@@ -0,0 +1,77 @@
+#ifndef SPECKLE_SERIALISE_DETACHED_REFERENCE
+#define SPECKLE_SERIALISE_DETACHED_REFERENCE
+
+#include "Active/Serialise/Package/Package.h"
+#include "Speckle/Serialise/Detached/DetachedWrap.h"
+#include "Speckle/Utility/String.h"
+
+namespace speckle::serialise {
+	
+	/*!
+	 Wrapper for references to a detached (serialised) object
+	 
+	 An object holding a child object that should be serialised as a detached object should wrap the child in this package for (de)serialisation
+	 */
+	class DetachedReference : public active::serialise::Package, std::reference_wrapper<active::serialise::Package> {
+	public:
+		
+		// MARK: - Types
+		
+			///Item reference base
+		using base = std::reference_wrapper<active::serialise::Package>;
+		
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param source The source package to wrap
+		 */
+		DetachedReference(Package& source) : base{source} {}
+		/*!
+		 Constructor
+		 @param source The source package to wrap
+		 */
+		DetachedReference(const active::serialise::Package& source) : base(const_cast<active::serialise::Package&>(source)) {}
+		DetachedReference(const DetachedReference& source) = delete;
+		/*!
+		 Destructor
+		 */
+		~DetachedReference() override = default;
+			
+		// MARK: - Functions (const)
+		
+		/*!
+		 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;
+	
+		// MARK: - Functions (mutating)
+		
+		/*!
+		 Set to the default package content
+		*/
+		void setDefault() override;
+		/*!
+		 Validate the cargo data
+		 @return True if the data has been validated
+		 */
+		bool validate() override;
+		
+	private:
+			///The reference value, i.e. a hash of the object content
+		mutable std::optional<database::RecordID> m_reference;
+			///The reference type
+		utility::String m_type;
+	};
+	
+}
+
+#endif	//SPECKLE_SERIALISE_DETACHED_REFERENCE
@@ -0,0 +1,92 @@
+#include "Speckle/Serialise/Detached/DetachedWrap.h"
+
+#include "Active/Serialise/Item/Wrapper/ValueWrap.h"
+#include "Active/Utility/BufferOut.h"
+#include "Active/Utility/SHA256.h"
+#include "Speckle/Utility/String.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::serialise;
+using namespace speckle::utility;
+
+#include <array>
+
+namespace {
+	
+		///Serialisation fields
+	enum FieldIndex {
+		refdID,
+	};
+
+		///Serialisation field IDs
+	static std::array fieldID = {
+		Identity{"id"},
+	};
+
+}
+
+/*--------------------------------------------------------------------
+	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 DetachedWrap::fillInventory(Inventory& inventory) const {
+	using enum Entry::Type;
+	if (!base::get().fillInventory(inventory))
+		return false;
+	inventory.merge(Inventory{
+		{
+			{ fieldID[refdID], refdID, element },
+		},
+	}.withType(&typeid(DetachedWrap)));
+	return true;
+} //DetachedWrap::fillInventory
+
+
+/*--------------------------------------------------------------------
+	Get the specified cargo
+ 
+	item: The inventory item to retrieve
+ 
+	return: The requested cargo (nullptr on failure)
+  --------------------------------------------------------------------*/
+Cargo::Unique DetachedWrap::getCargo(const Inventory::Item& item) const {
+	if (item.ownerType != &typeid(DetachedWrap))
+		return base::get().getCargo(item);
+	using namespace active::serialise;
+	switch (item.index) {
+		case refdID: {
+			if (!m_reference) {
+				if (m_bufferOut == nullptr)
+					return nullptr;	//TODO: Consider throwing an exception here
+				auto serialisedData = m_bufferOut->getOutput();
+					//Produce a hash from the serialised object. NB: We are currently using only the first 32 chars of the SHA256 hash
+				m_reference = (active::utility::SHA256() << serialisedData << String{"}"}).base64Hash().substr(0, 32);
+			}
+			return std::make_unique<ValueWrap<RecordID>>(*m_reference);
+		}
+		default:
+			return nullptr;	//Requested an unknown index
+	}
+} //DetachedWrap::getCargo
+
+
+/*--------------------------------------------------------------------
+	Set to the default package content
+  --------------------------------------------------------------------*/
+void DetachedWrap::setDefault() {
+	m_reference = String{};
+} //DetachedWrap::setDefault
+
+
+/*--------------------------------------------------------------------
+	Validate the cargo data
+ 
+	return: True if the data has been validated
+  --------------------------------------------------------------------*/
+bool DetachedWrap::validate() {
+	return m_reference && base::get().validate();
+} //DetachedWrap::validate
@@ -0,0 +1,89 @@
+#ifndef SPECKLE_SERIALISE_DETACHED_WRAP
+#define SPECKLE_SERIALISE_DETACHED_WRAP
+
+#include "Active/Serialise/Package/Package.h"
+
+#include "Speckle/Database/Identity/RecordID.h"
+
+namespace active::utility {
+	class BufferOut;
+}
+
+namespace speckle::serialise {
+	
+	/*!
+	 Lightweight interface wrapper for a detached object
+	 
+	 The wrapper generates a new reference ID for the object during serialisation, embedding it in the output
+	 */
+	class DetachedWrap : public active::serialise::Package, public std::reference_wrapper<active::serialise::Package> {
+	public:
+		
+		// MARK: - Types
+		
+			///Item reference base
+		using base = std::reference_wrapper<active::serialise::Package>;
+		
+		// MARK: - Constructors
+		
+		/*!
+		 Constructor
+		 @param source The source package to wrap
+		 @param bufferOut The serialisation output buffer
+		 */
+		DetachedWrap(active::serialise::Package& source, active::utility::BufferOut& bufferOut) : base(source), m_bufferOut{&bufferOut} {}
+		/*!
+		 Constructor
+		 @param source The source package to wrap
+		 @param bufferOut The serialisation output buffer
+		 */
+		DetachedWrap(const active::serialise::Package& source, active::utility::BufferOut& bufferOut) :
+				DetachedWrap{const_cast<active::serialise::Package&>(source), bufferOut} {}
+		/*!
+		 Copy constructor
+		 @param source The object to copy
+		 */
+		DetachedWrap(const DetachedWrap& source) : base(source), m_reference{source.m_reference} {}
+			
+		// MARK: - Functions (const)
+		
+		/*!
+		 Get the detached object reference
+		 @return The detached object reference (nullopt if the reference has not been determined yet - call after (de)serialisation)
+		 */
+		std::optional<database::RecordID> getReference() const { return m_reference; }
+		/*!
+		 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;
+	
+		// MARK: - Functions (mutating)
+		
+		/*!
+		 Set to the default package content
+		 */
+		void setDefault() override;
+		/*!
+		 Validate the cargo data
+		 @return True if the data has been validated
+		 */
+		bool validate() override;
+		
+	private:
+			///The detached record reference
+		mutable std::optional<database::RecordID> m_reference;
+			///The serialisation output buffer
+		active::utility::BufferOut* m_bufferOut;
+	};
+	
+}
+
+#endif	//SPECKLE_SERIALISE_DETACHED_WRAP
@@ -0,0 +1,89 @@
+#include "Speckle/Serialise/Detached/DetachmentManager.h"
+
+#include "Active/Utility/BufferOut.h"
+#include "Speckle/Serialise/Detached/DetachedWrap.h"
+#include "Speckle/Serialise/Detached/Storage/DetachedObjectStore.h"
+
+using namespace active::serialise;
+using namespace speckle::database;
+using namespace speckle::serialise;
+using namespace speckle::utility;
+
+
+/*--------------------------------------------------------------------
+	Default constructor
+  --------------------------------------------------------------------*/
+DetachmentManager::DetachmentManager() {
+	
+} //DetachmentManager::DetachmentManager
+
+
+/*--------------------------------------------------------------------
+	Destructor
+  --------------------------------------------------------------------*/
+DetachmentManager::~DetachmentManager() {
+	
+} //DetachmentManager::~DetachmentManager
+
+
+/*--------------------------------------------------------------------
+	Send cargo as a detached object
+ 
+	package: The package to become a detached object
+	identity: The package identity (name, optional namespace)
+ 
+	return: The ID of the sent detached object
+  --------------------------------------------------------------------*/
+std::optional<RecordID> DetachmentManager::send(Package&& package, const Identity& identity) const {
+	auto transport = m_transport.lock();
+	if (!transport)
+		throw;	//TODO: Throw meaningful exception type
+		//Prepare the detached object data
+	String serialisedData;
+	active::utility::BufferOut buffer{serialisedData};
+		//The wrapper will manage the object serialisation and generate a unique reference based on the output
+	DetachedWrap wrapper{package, buffer};
+	transport->send(std::forward<Cargo&&>(wrapper), identity, serialisedData);
+	auto detachedReference = wrapper.getReference();
+		//If a reference is obtained, file/cache the object as required
+	if (detachedReference) {
+		m_store->file(*detachedReference, serialisedData);
+		if (m_cache)
+			m_cache->file(*detachedReference, serialisedData);
+	}
+	return detachedReference;
+} //DetachmentManager::send
+
+
+/*--------------------------------------------------------------------
+	Receive cargo from a detached object
+ 
+	id: The ID of the detached object to receive
+	package: The package to receive the detached object data
+	identity: The package identity (name, optional namespace)
+ 
+	return: True if the detached object was found and received
+  --------------------------------------------------------------------*/
+bool DetachmentManager::receive(const database::RecordID& id, Package&& package, const Identity& identity) const {
+	return false;	//TODO: Implement when we start receiving in Archicad
+} //DetachmentManager::receive
+
+
+/*--------------------------------------------------------------------
+	Set the manager primary storage
+ 
+	store: the primary storage (this is the long-term storage, e.g. a remote/cloud database)
+  --------------------------------------------------------------------*/
+void DetachmentManager::setStore(std::unique_ptr<DetachedObjectStore> store) {
+	m_store = std::move(store);
+} //DetachmentManager::setStore
+
+
+/*--------------------------------------------------------------------
+	Set the manager storage cache
+ 
+	cache: the storage cache (this is intended to provide faster access than the primary storage for repeated detached objects)
+  --------------------------------------------------------------------*/
+void DetachmentManager::setCache(std::unique_ptr<DetachedObjectStore> cache) {
+	m_cache = std::move(cache);
+} //DetachmentManager::setCache
@@ -0,0 +1,82 @@
+#ifndef SPECKLE_SERIALISE_DETACHMENT_MANAGER
+#define SPECKLE_SERIALISE_DETACHMENT_MANAGER
+
+#include "Active/Serialise/Manager.h"
+#include "Active/Serialise/Transport.h"
+#include "Speckle/Database/Identity/RecordID.h"
+
+namespace active::serialise {
+	class Package;
+}
+
+namespace speckle::serialise {
+	
+	class DetachedObjectStore;
+	
+	/*!
+	 Manager for detached (serialised) objects
+	 
+	 Pass this manager to the target transport for (de)serialisation supporting detached objects. Note that the manager is expected to know how
+	 to send/receive detached objects, e.g. to a JS portal, remote server or local database (or some combo)
+	 */
+	class DetachmentManager : public virtual active::serialise::Manager {
+	public:
+		
+		// MARK: - Types
+		
+			///Base class
+		using base = active::serialise::Manager;
+		
+		/*!
+		 Default constructor
+		 */
+		DetachmentManager();
+		DetachmentManager(const DetachmentManager&) = delete;
+		/*!
+		 Destructor
+		 */
+		~DetachmentManager();
+			
+		// MARK: - Functions (const)
+		
+		/*!
+			Send cargo as a detached object
+			@param package The package to become a detached object
+			@param identity The package identity (name, optional namespace)
+			@return The ID of the sent detached object
+		*/
+		std::optional<database::RecordID> send(active::serialise::Package&& package, const active::serialise::Identity& identity) const;
+		/*!
+			Receive cargo from a detached object
+			@param id The ID of the detached object to receive
+			@param package The package to receive the detached object data
+			@param identity The package identity (name, optional namespace)
+			@return True if the detached object was found and received
+		*/
+		bool receive(const database::RecordID& id, active::serialise::Package&& package, const active::serialise::Identity& identity) const;
+		
+	// MARK: - Functions (mutating)
+
+		/*!
+			Set the manager primary storage
+			@param store the primary storage (this is the long-term storage, e.g. a remote/cloud database)
+		*/
+		void setStore(std::unique_ptr<DetachedObjectStore> store);
+		/*!
+			Set the manager storage cache
+			@param cache the storage cache (this is intended to provide faster access than the primary storage for repeated detached objects)
+		*/
+		void setCache(std::unique_ptr<DetachedObjectStore> cache);
+
+	private:
+			///The manager serialisation transport (NB - this is expected to be a shared resource, so the manager does not own it)
+		std::weak_ptr<active::serialise::Transport> m_transport;
+			///The primary store for sending/retrieving detached objects
+		std::unique_ptr<DetachedObjectStore> m_store;
+			///A cache for detached objects - can be used as a local store to save
+		std::unique_ptr<DetachedObjectStore> m_cache;
+	};
+	
+}
+
+#endif	//SPECKLE_SERIALISE_DETACHMENT_MANAGER
@@ -0,0 +1,52 @@
+#ifndef SPECKLE_SERIALISE_DETACHED_MEMORY_STORE
+#define SPECKLE_SERIALISE_DETACHED_MEMORY_STORE
+
+#include "Speckle/Serialise/Detached/Storage/DetachedObjectStore.h"
+
+#include <unordered_map>
+
+namespace speckle::serialise {
+	
+	/*!
+	 Memory-based storage for detached objects
+	 
+	 Detached object serialised data is held in a simple unordered_map keying the data against the object reference.
+	 This class primarily intended for collecting the JSON from detached objects and holding until they can be forwarded to the server. The data
+	 will not persist beyond this usage.
+	 */
+	class DetachedMemoryStore : public DetachedObjectStore, public std::unordered_map<database::RecordID, utility::String> {
+	public:
+		
+		// MARK: - Types
+		
+		using base = std::unordered_map<database::RecordID, utility::String>;
+			
+		// MARK: - Functions (const)
+		
+		/*!
+		 Retrieve a detached object from storage
+		 @param reference The required object reference
+		 @return The object data (nullopt if the object cannot be found in storage)
+		 */
+		utility::String::Option retrieve(const database::RecordID& reference) const override {
+			if (auto iter = base::find(reference); iter != base::end())
+				return iter->second;
+			return std::nullopt;
+		}
+	
+		// MARK: - Functions (mutating)
+		
+		/*!
+		 File a detached object in storage
+		 @param reference The object reference (typically a hash generated from the object data)
+		 @param data The object data (currently expected to be serialised as JSON)
+		 @return True if the object was filed (typically ignored if it duplicates an object already in the store)
+		 */
+		bool file(const database::RecordID& reference, const utility::String& data) override {
+			return base::insert(std::make_pair(reference, data)).second;
+		}
+	};
+	
+}
+
+#endif	//SPECKLE_SERIALISE_DETACHED_MEMORY_STORE
@@ -0,0 +1,46 @@
+#ifndef SPECKLE_SERIALISE_DETACHED_OBJECT_STORE
+#define SPECKLE_SERIALISE_DETACHED_OBJECT_STORE
+
+#include "Speckle/Database/Identity/RecordID.h"
+#include "Speckle/Utility/String.h"
+
+namespace speckle::serialise {
+	
+	/*!
+	 Interface for objects that store/cache/send/receive detached objects
+	 
+	 It is currently assumed that objects will be serialised and can be held in a string. This can be revisited in future if binary data is required.
+	 */
+	class DetachedObjectStore {
+	public:
+		
+		// MARK: Constructors
+		
+		/*!
+		 Destructor
+		 */
+		virtual ~DetachedObjectStore() {}
+			
+		// MARK: - Functions (const)
+		
+		/*!
+		 Retrieve a detached object from storage
+		 @param reference The required object reference
+		 @return The object data (nullopt if the object cannot be found in storage)
+		 */
+		virtual utility::String::Option retrieve(const database::RecordID& reference) const = 0;
+	
+		// MARK: - Functions (mutating)
+		
+		/*!
+		 File a detached object in storage
+		 @param reference The object reference (typically a hash generated from the object data)
+		 @param data The object data (currently expected to be serialised as JSON)
+		 @return True if the object was filed (typically rejected if it duplicates an object already in the store)
+		 */
+		virtual bool file(const database::RecordID& reference, const utility::String& data) = 0;
+	};
+	
+}
+
+#endif	//SPECKLE_SERIALISE_DETACHED_OBJECT_STORE
@@ -18,11 +18,29 @@
 		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 */; };
+		215F087D2CA18E1400CD343B /* Element.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08782CA18E1400CD343B /* Element.cpp */; };
+		215F087E2CA18E1400CD343B /* Element.h in Headers */ = {isa = PBXBuildFile; fileRef = 215F08792CA18E1400CD343B /* Element.h */; };
+		215F088B2CA195EC00CD343B /* ArchicadDBaseCore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08872CA195EC00CD343B /* ArchicadDBaseCore.cpp */; };
+		215F088C2CA195EC00CD343B /* ArchicadDBaseCore.h in Headers */ = {isa = PBXBuildFile; fileRef = 215F08882CA195EC00CD343B /* ArchicadDBaseCore.h */; };
+		215F088D2CA195EC00CD343B /* ArchicadElementDBaseEngine.h in Headers */ = {isa = PBXBuildFile; fileRef = 215F08892CA195EC00CD343B /* ArchicadElementDBaseEngine.h */; };
+		215F08952CA19AF800CD343B /* BIMElementDatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 215F08932CA19AF800CD343B /* BIMElementDatabase.cpp */; };
+		215F08962CA19AF800CD343B /* BIMElementDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 215F08942CA19AF800CD343B /* BIMElementDatabase.h */; };
+		219245FE2CA2CC4300CF5703 /* BIMRecord.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219245FA2CA2CC4300CF5703 /* BIMRecord.cpp */; };
+		219245FF2CA2CC4300CF5703 /* BIMRecord.h in Headers */ = {isa = PBXBuildFile; fileRef = 219245FD2CA2CC4300CF5703 /* BIMRecord.h */; };
+		219246032CA2CE2700CF5703 /* BIMLink.h in Headers */ = {isa = PBXBuildFile; fileRef = 219246012CA2CE2700CF5703 /* BIMLink.h */; };
+		219246042CA2CE2700CF5703 /* BIMLink.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219246022CA2CE2700CF5703 /* BIMLink.cpp */; };
+		219246082CA2ED2F00CF5703 /* ArchicadElementDBaseEngine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219246072CA2ED2F00CF5703 /* ArchicadElementDBaseEngine.cpp */; };
+		219246122CA34DCE00CF5703 /* Mesh.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2192460E2CA34DCE00CF5703 /* Mesh.cpp */; };
+		219246132CA34DCE00CF5703 /* Mesh.h in Headers */ = {isa = PBXBuildFile; fileRef = 2192460F2CA34DCE00CF5703 /* Mesh.h */; };
 		2193517B2C624FC100E5A69C /* MenuSubscriber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219351782C624FC100E5A69C /* MenuSubscriber.cpp */; };
 		2193519B2C6278D900E5A69C /* SelectionSubscriber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219351992C6278D900E5A69C /* SelectionSubscriber.cpp */; };
 		219351B12C62CC1A00E5A69C /* Guid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219351AC2C62CC1A00E5A69C /* Guid.cpp */; };
 		219351B32C62CC1A00E5A69C /* String.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 219351AE2C62CC1A00E5A69C /* String.cpp */; };
 		2199881E2BD833830035E5EA /* libArchicad27.a in CopyFiles */ = {isa = PBXBuildFile; fileRef = 21379E082AE47A6400A1584C /* libArchicad27.a */; };
+		21AEF9BA2CA606B5000B8681 /* DetachedReference.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9B92CA606B4000B8681 /* DetachedReference.cpp */; };
+		21AEF9BC2CA6DF84000B8681 /* DetachmentManager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9BB2CA6DF84000B8681 /* DetachmentManager.cpp */; };
+		21AEF9BE2CA6FDA4000B8681 /* DetachedWrap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21AEF9BD2CA6FDA4000B8681 /* DetachedWrap.cpp */; };
+		21AEF9DD2CAAA4EA000B8681 /* DetachedObjectStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 21AEF9DB2CAAA4EA000B8681 /* DetachedObjectStore.h */; };
 		21B67D002C7CE15100FD64FC /* Exception.h in Headers */ = {isa = PBXBuildFile; fileRef = 21B67CFE2C7CE15100FD64FC /* Exception.h */; };
 		21B67D0D2C7E0E8D00FD64FC /* ErrorReport.h in Headers */ = {isa = PBXBuildFile; fileRef = 21B67D092C7E0E8D00FD64FC /* ErrorReport.h */; };
 		21B67D0E2C7E0E8D00FD64FC /* ErrorReport.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21B67D0C2C7E0E8D00FD64FC /* ErrorReport.cpp */; };
@@ -31,7 +49,6 @@
 		21D0BD2B2C86FC350077E104 /* Record.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21D0BD252C86FC350077E104 /* Record.cpp */; };
 		21D0BD2C2C86FC350077E104 /* Record.h in Headers */ = {isa = PBXBuildFile; fileRef = 21D0BD262C86FC350077E104 /* Record.h */; };
 		21D0BD312C86FE090077E104 /* Index.h in Headers */ = {isa = PBXBuildFile; fileRef = 21D0BD2D2C86FE090077E104 /* Index.h */; };
-		21D0BD322C86FE090077E104 /* Link.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21D0BD2E2C86FE090077E104 /* Link.cpp */; };
 		21D0BD332C86FE090077E104 /* Link.h in Headers */ = {isa = PBXBuildFile; fileRef = 21D0BD2F2C86FE090077E104 /* Link.h */; };
 		21D0BD4D2C8901A00077E104 /* ServerInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 21D0BD4B2C8901A00077E104 /* ServerInfo.h */; };
 		21D0BD4E2C8901A00077E104 /* ServerInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 21D0BD4C2C8901A00077E104 /* ServerInfo.cpp */; };
@@ -114,10 +131,26 @@
 		215F085B2C9AE23200CD343B /* SpeckleResource.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SpeckleResource.h; sourceTree = "<group>"; };
 		215F08622C9AE3D200CD343B /* Speckle.grc */ = {isa = PBXFileReference; lastKnownFileType = text; path = Speckle.grc; sourceTree = "<group>"; };
 		215F08652C9B006700CD343B /* ProjectEvent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ProjectEvent.cpp; sourceTree = "<group>"; };
+		215F08782CA18E1400CD343B /* Element.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Element.cpp; sourceTree = "<group>"; };
+		215F08792CA18E1400CD343B /* Element.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Element.h; sourceTree = "<group>"; };
+		215F08872CA195EC00CD343B /* ArchicadDBaseCore.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ArchicadDBaseCore.cpp; sourceTree = "<group>"; };
+		215F08882CA195EC00CD343B /* ArchicadDBaseCore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArchicadDBaseCore.h; sourceTree = "<group>"; };
+		215F08892CA195EC00CD343B /* ArchicadElementDBaseEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArchicadElementDBaseEngine.h; sourceTree = "<group>"; };
+		215F08932CA19AF800CD343B /* BIMElementDatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BIMElementDatabase.cpp; sourceTree = "<group>"; };
+		215F08942CA19AF800CD343B /* BIMElementDatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BIMElementDatabase.h; sourceTree = "<group>"; };
 		2167E2782C4911E2000827D3 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
 		2167E2792C4911EB000827D3 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
 		2167E27C2C49121F000827D3 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
 		218953A32C0C9CB00078F182 /* Version.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Version.h; sourceTree = "<group>"; };
+		219245FA2CA2CC4300CF5703 /* BIMRecord.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BIMRecord.cpp; sourceTree = "<group>"; };
+		219245FD2CA2CC4300CF5703 /* BIMRecord.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BIMRecord.h; sourceTree = "<group>"; };
+		219246002CA2CCD700CF5703 /* BIMRecordID.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = BIMRecordID.h; sourceTree = "<group>"; };
+		219246012CA2CE2700CF5703 /* BIMLink.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BIMLink.h; sourceTree = "<group>"; };
+		219246022CA2CE2700CF5703 /* BIMLink.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BIMLink.cpp; sourceTree = "<group>"; };
+		219246052CA2CFF000CF5703 /* BIMIndex.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = BIMIndex.h; sourceTree = "<group>"; };
+		219246072CA2ED2F00CF5703 /* ArchicadElementDBaseEngine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ArchicadElementDBaseEngine.cpp; sourceTree = "<group>"; };
+		2192460E2CA34DCE00CF5703 /* Mesh.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Mesh.cpp; sourceTree = "<group>"; };
+		2192460F2CA34DCE00CF5703 /* Mesh.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Mesh.h; sourceTree = "<group>"; };
 		2193516A2C62318B00E5A69C /* ActiveLib.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = ActiveLib.xcodeproj; path = ../../ActiveLib/ActiveLib.xcodeproj; sourceTree = "<group>"; };
 		219351782C624FC100E5A69C /* MenuSubscriber.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MenuSubscriber.cpp; sourceTree = "<group>"; };
 		219351792C624FC100E5A69C /* MenuSubscriber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MenuSubscriber.h; sourceTree = "<group>"; };
@@ -130,6 +163,14 @@
 		219351AE2C62CC1A00E5A69C /* String.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = String.cpp; sourceTree = "<group>"; };
 		219351AF2C62CC1A00E5A69C /* String.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = String.h; sourceTree = "<group>"; };
 		219712682BE7E2D500D9EF7E /* Serialisation.md */ = {isa = PBXFileReference; lastKnownFileType = net.daringfireball.markdown; path = Serialisation.md; sourceTree = "<group>"; };
+		21AEF9B32CA5F7CF000B8681 /* DetachedWrap.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachedWrap.h; sourceTree = "<group>"; };
+		21AEF9B52CA5FA02000B8681 /* DetachedReference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachedReference.h; sourceTree = "<group>"; };
+		21AEF9B72CA5FCB6000B8681 /* DetachmentManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachmentManager.h; sourceTree = "<group>"; };
+		21AEF9B92CA606B4000B8681 /* DetachedReference.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DetachedReference.cpp; sourceTree = "<group>"; };
+		21AEF9BB2CA6DF84000B8681 /* DetachmentManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DetachmentManager.cpp; sourceTree = "<group>"; };
+		21AEF9BD2CA6FDA4000B8681 /* DetachedWrap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DetachedWrap.cpp; sourceTree = "<group>"; };
+		21AEF9DB2CAAA4EA000B8681 /* DetachedObjectStore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachedObjectStore.h; sourceTree = "<group>"; };
+		21AEF9DF2CAAC2AF000B8681 /* DetachedMemoryStore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetachedMemoryStore.h; sourceTree = "<group>"; };
 		21B67CFE2C7CE15100FD64FC /* Exception.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Exception.h; sourceTree = "<group>"; };
 		21B67D092C7E0E8D00FD64FC /* ErrorReport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ErrorReport.h; sourceTree = "<group>"; };
 		21B67D0C2C7E0E8D00FD64FC /* ErrorReport.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ErrorReport.cpp; sourceTree = "<group>"; };
@@ -138,7 +179,6 @@
 		21D0BD252C86FC350077E104 /* Record.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Record.cpp; sourceTree = "<group>"; };
 		21D0BD262C86FC350077E104 /* Record.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Record.h; sourceTree = "<group>"; };
 		21D0BD2D2C86FE090077E104 /* Index.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Index.h; sourceTree = "<group>"; };
-		21D0BD2E2C86FE090077E104 /* Link.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Link.cpp; sourceTree = "<group>"; };
 		21D0BD2F2C86FE090077E104 /* Link.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Link.h; sourceTree = "<group>"; };
 		21D0BD4B2C8901A00077E104 /* ServerInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ServerInfo.h; sourceTree = "<group>"; };
 		21D0BD4C2C8901A00077E104 /* ServerInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ServerInfo.cpp; sourceTree = "<group>"; };
@@ -213,6 +253,7 @@
 				21F93AE82B2F406D009A2C5B /* Environment */,
 				21F93ACC2B2B67FC009A2C5B /* Event */,
 				21F69F1B2C6A0FE2008B6A06 /* Interface */,
+				219246112CA34DCE00CF5703 /* Primitive */,
 				21F69F952C71087A008B6A06 /* Record */,
 				212A834E2AE47AD9001EAFE7 /* Serialise */,
 				215F085B2C9AE23200CD343B /* SpeckleResource.h */,
@@ -226,6 +267,7 @@
 			isa = PBXGroup;
 			children = (
 				2167E27C2C49121F000827D3 /* CMakeLists.txt */,
+				21AEF9C72CA818EA000B8681 /* Detached */,
 				21F69F3A2C6B880B008B6A06 /* JSBase */,
 				219712682BE7E2D500D9EF7E /* Serialisation.md */,
 			);
@@ -263,6 +305,25 @@
 			path = RINT;
 			sourceTree = SOURCE_ROOT;
 		};
+		215F087A2CA18E1400CD343B /* Element */ = {
+			isa = PBXGroup;
+			children = (
+				215F08782CA18E1400CD343B /* Element.cpp */,
+				215F08792CA18E1400CD343B /* Element.h */,
+			);
+			path = Element;
+			sourceTree = "<group>";
+		};
+		215F088A2CA195EC00CD343B /* ArchicadDBase */ = {
+			isa = PBXGroup;
+			children = (
+				215F08872CA195EC00CD343B /* ArchicadDBaseCore.cpp */,
+				215F08882CA195EC00CD343B /* ArchicadDBaseCore.h */,
+				219246062CA2D22D00CF5703 /* Element */,
+			);
+			path = ArchicadDBase;
+			sourceTree = "<group>";
+		};
 		218953A92C0F29FB0078F182 /* EventTests */ = {
 			isa = PBXGroup;
 			children = (
@@ -270,6 +331,32 @@
 			name = EventTests;
 			sourceTree = "<group>";
 		};
+		219246062CA2D22D00CF5703 /* Element */ = {
+			isa = PBXGroup;
+			children = (
+				219246072CA2ED2F00CF5703 /* ArchicadElementDBaseEngine.cpp */,
+				215F08892CA195EC00CD343B /* ArchicadElementDBaseEngine.h */,
+			);
+			path = Element;
+			sourceTree = "<group>";
+		};
+		219246102CA34DCE00CF5703 /* Mesh */ = {
+			isa = PBXGroup;
+			children = (
+				2192460E2CA34DCE00CF5703 /* Mesh.cpp */,
+				2192460F2CA34DCE00CF5703 /* Mesh.h */,
+			);
+			path = Mesh;
+			sourceTree = "<group>";
+		};
+		219246112CA34DCE00CF5703 /* Primitive */ = {
+			isa = PBXGroup;
+			children = (
+				219246102CA34DCE00CF5703 /* Mesh */,
+			);
+			path = Primitive;
+			sourceTree = "<group>";
+		};
 		2193516B2C62318B00E5A69C /* Products */ = {
 			isa = PBXGroup;
 			children = (
@@ -329,11 +416,36 @@
 			path = SpeckleLibDoctest;
 			sourceTree = "<group>";
 		};
+		21AEF9C72CA818EA000B8681 /* Detached */ = {
+			isa = PBXGroup;
+			children = (
+				21AEF9B92CA606B4000B8681 /* DetachedReference.cpp */,
+				21AEF9B52CA5FA02000B8681 /* DetachedReference.h */,
+				21AEF9BD2CA6FDA4000B8681 /* DetachedWrap.cpp */,
+				21AEF9B32CA5F7CF000B8681 /* DetachedWrap.h */,
+				21AEF9BB2CA6DF84000B8681 /* DetachmentManager.cpp */,
+				21AEF9B72CA5FCB6000B8681 /* DetachmentManager.h */,
+				21AEF9DE2CAAA78A000B8681 /* Storage */,
+			);
+			path = Detached;
+			sourceTree = "<group>";
+		};
+		21AEF9DE2CAAA78A000B8681 /* Storage */ = {
+			isa = PBXGroup;
+			children = (
+				21AEF9DB2CAAA4EA000B8681 /* DetachedObjectStore.h */,
+				21AEF9DF2CAAC2AF000B8681 /* DetachedMemoryStore.h */,
+			);
+			path = Storage;
+			sourceTree = "<group>";
+		};
 		21D0BD1F2C86F0280077E104 /* Database */ = {
 			isa = PBXGroup;
 			children = (
 				21D0BD1D2C86F0280077E104 /* AccountDatabase.cpp */,
 				21D0BD1E2C86F0280077E104 /* AccountDatabase.h */,
+				215F08932CA19AF800CD343B /* BIMElementDatabase.cpp */,
+				215F08942CA19AF800CD343B /* BIMElementDatabase.h */,
 				21D0BD272C86FC350077E104 /* Content */,
 				21D0BD302C86FE090077E104 /* Identity */,
 				21D0BDB02C8F8AB60077E104 /* Storage */,
@@ -344,6 +456,8 @@
 		21D0BD272C86FC350077E104 /* Content */ = {
 			isa = PBXGroup;
 			children = (
+				219245FA2CA2CC4300CF5703 /* BIMRecord.cpp */,
+				219245FD2CA2CC4300CF5703 /* BIMRecord.h */,
 				21D0BD252C86FC350077E104 /* Record.cpp */,
 				21D0BD262C86FC350077E104 /* Record.h */,
 			);
@@ -353,8 +467,11 @@
 		21D0BD302C86FE090077E104 /* Identity */ = {
 			isa = PBXGroup;
 			children = (
+				219246052CA2CFF000CF5703 /* BIMIndex.h */,
+				219246022CA2CE2700CF5703 /* BIMLink.cpp */,
+				219246012CA2CE2700CF5703 /* BIMLink.h */,
+				219246002CA2CCD700CF5703 /* BIMRecordID.h */,
 				21D0BD2D2C86FE090077E104 /* Index.h */,
-				21D0BD2E2C86FE090077E104 /* Link.cpp */,
 				21D0BD2F2C86FE090077E104 /* Link.h */,
 				21D0BDE42C943D3F0077E104 /* RecordID.h */,
 			);
@@ -374,6 +491,7 @@
 		21D0BDB02C8F8AB60077E104 /* Storage */ = {
 			isa = PBXGroup;
 			children = (
+				215F088A2CA195EC00CD343B /* ArchicadDBase */,
 				21D0BDAF2C8F8AB60077E104 /* DocumentStore */,
 			);
 			path = Storage;
@@ -462,6 +580,7 @@
 		21F69F952C71087A008B6A06 /* Record */ = {
 			isa = PBXGroup;
 			children = (
+				215F087A2CA18E1400CD343B /* Element */,
 				21F69F942C71087A008B6A06 /* Credentials */,
 			);
 			path = Record;
@@ -500,19 +619,27 @@
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				215F088C2CA195EC00CD343B /* ArchicadDBaseCore.h in Headers */,
 				21D0BDE72C943D3F0077E104 /* RecordID.h in Headers */,
 				21D0BD212C86F0280077E104 /* AccountDatabase.h in Headers */,
 				210CC86F2C7E879700610F58 /* ArgumentBase.h in Headers */,
 				210CC8A02C81E34400610F58 /* Platform.h in Headers */,
+				219246132CA34DCE00CF5703 /* Mesh.h in Headers */,
+				219246032CA2CE2700CF5703 /* BIMLink.h in Headers */,
 				21B67D0D2C7E0E8D00FD64FC /* ErrorReport.h in Headers */,
+				215F08962CA19AF800CD343B /* BIMElementDatabase.h in Headers */,
 				21D0BD332C86FE090077E104 /* Link.h in Headers */,
 				21D0BD5A2C8910400077E104 /* UserInfo.h in Headers */,
 				21D0BD562C890B1C0077E104 /* ServerMigration.h in Headers */,
 				210CC88F2C81A98500610F58 /* Guid64.h in Headers */,
+				21AEF9DD2CAAA4EA000B8681 /* DetachedObjectStore.h in Headers */,
+				215F088D2CA195EC00CD343B /* ArchicadElementDBaseEngine.h in Headers */,
 				21B67D002C7CE15100FD64FC /* Exception.h in Headers */,
 				21D0BD2C2C86FC350077E104 /* Record.h in Headers */,
 				21D0BDB42C8F8AB60077E104 /* DocumentStoreCore.h in Headers */,
+				215F087E2CA18E1400CD343B /* Element.h in Headers */,
 				215F08562C99DA8D00CD343B /* Project.h in Headers */,
+				219245FF2CA2CC4300CF5703 /* BIMRecord.h in Headers */,
 				210CC8802C80CD2A00610F58 /* BridgeChild.h in Headers */,
 				21D0BD4D2C8901A00077E104 /* ServerInfo.h in Headers */,
 				21D0BDB52C8F8AB60077E104 /* DocumentStoreEngine.h in Headers */,
@@ -646,29 +773,38 @@
 				21F69FA62C733EDA008B6A06 /* BridgeArgument.cpp in Sources */,
 				21F69F682C6DFB01008B6A06 /* RunMethod.cpp in Sources */,
 				21F69F812C6FF3B0008B6A06 /* BridgeArgumentWrap.cpp in Sources */,
+				215F088B2CA195EC00CD343B /* ArchicadDBaseCore.cpp in Sources */,
 				2193517B2C624FC100E5A69C /* MenuSubscriber.cpp in Sources */,
 				21F69F612C6D0286008B6A06 /* GetBindingsMethodNames.cpp in Sources */,
 				215F08662C9B006800CD343B /* ProjectEvent.cpp in Sources */,
 				21D0BDBD2C90F2830077E104 /* DocStoreSubscriber.cpp in Sources */,
 				21D0BDB32C8F8AB60077E104 /* DocumentStoreCore.cpp in Sources */,
+				219246082CA2ED2F00CF5703 /* ArchicadElementDBaseEngine.cpp in Sources */,
 				21F93AEC2B2F406E009A2C5B /* Addon.cpp in Sources */,
+				215F087D2CA18E1400CD343B /* Element.cpp in Sources */,
 				21D0BD4E2C8901A00077E104 /* ServerInfo.cpp in Sources */,
 				21B67D0E2C7E0E8D00FD64FC /* ErrorReport.cpp in Sources */,
 				21F69F7E2C6FD9FC008B6A06 /* GetCallResult.cpp in Sources */,
+				219245FE2CA2CC4300CF5703 /* BIMRecord.cpp in Sources */,
+				21AEF9BE2CA6FDA4000B8681 /* DetachedWrap.cpp in Sources */,
 				2193519B2C6278D900E5A69C /* SelectionSubscriber.cpp in Sources */,
 				21D0BD2B2C86FC350077E104 /* Record.cpp in Sources */,
+				219246042CA2CE2700CF5703 /* BIMLink.cpp in Sources */,
+				215F08952CA19AF800CD343B /* BIMElementDatabase.cpp in Sources */,
+				219246122CA34DCE00CF5703 /* Mesh.cpp in Sources */,
 				21D0BD592C8910400077E104 /* UserInfo.cpp in Sources */,
 				210CC8902C81A98500610F58 /* Guid64.cpp in Sources */,
 				21D0BDC42C9241940077E104 /* ProjectSubscriber.cpp in Sources */,
-				21D0BD322C86FE090077E104 /* Link.cpp in Sources */,
 				219351B32C62CC1A00E5A69C /* String.cpp in Sources */,
 				219351B12C62CC1A00E5A69C /* Guid.cpp in Sources */,
 				21F69F512C6CCC25008B6A06 /* BrowserBridge.cpp in Sources */,
+				21AEF9BC2CA6DF84000B8681 /* DetachmentManager.cpp in Sources */,
 				215F08552C99DA8D00CD343B /* Project.cpp in Sources */,
 				21F69F3B2C6B880C008B6A06 /* JSBaseTransport.cpp in Sources */,
 				210CC89F2C81E34400610F58 /* Platform.cpp in Sources */,
 				21D0BD202C86F0280077E104 /* AccountDatabase.cpp in Sources */,
 				21F69F962C71087A008B6A06 /* Account.cpp in Sources */,
+				21AEF9BA2CA606B5000B8681 /* DetachedReference.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -20,9 +20,16 @@
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Speckle\Database\AccountDatabase.h" />
+    <ClInclude Include="Speckle\Database\BIMElementDatabase.h" />
+    <ClInclude Include="Speckle\Database\Content\BIMRecord.h" />
    <ClInclude Include="Speckle\Database\Content\Record.h" />
+    <ClInclude Include="Speckle\Database\Identity\BIMIndex.h" />
+    <ClInclude Include="Speckle\Database\Identity\BIMLink.h" />
+    <ClInclude Include="Speckle\Database\Identity\BIMRecordID.h" />
    <ClInclude Include="Speckle\Database\Identity\Index.h" />
    <ClInclude Include="Speckle\Database\Identity\Link.h" />
+    <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\ArchicadDBaseCore.h" />
+    <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\Element\ArchicadElementDBaseEngine.h" />
    <ClInclude Include="Speckle\Database\Storage\DocumentStore\DocumentStoreCore.h" />
    <ClInclude Include="Speckle\Database\Storage\DocumentStore\DocumentStoreEngine.h" />
    <ClInclude Include="Speckle\Environment\Addon.h" />
@@ -54,10 +61,17 @@
    <ClInclude Include="Speckle\Interface\Browser\JSPortal.h" />
    <ClInclude Include="Speckle\Interface\Browser\NamedFunction.h" />
    <ClInclude Include="Speckle\Interface\Browser\PlatformBinding.h" />
+    <ClInclude Include="Speckle\Primitive\Mesh\Mesh.h" />
    <ClInclude Include="Speckle\Record\Credentials\Account.h" />
    <ClInclude Include="Speckle\Record\Credentials\ServerInfo.h" />
    <ClInclude Include="Speckle\Record\Credentials\ServerMigration.h" />
    <ClInclude Include="Speckle\Record\Credentials\UserInfo.h" />
+    <ClInclude Include="Speckle\Record\Element\Element.h" />
+    <ClInclude Include="Speckle\Serialise\Detached\DetachedReference.h" />
+    <ClInclude Include="Speckle\Serialise\Detached\DetachedWrap.h" />
+    <ClInclude Include="Speckle\Serialise\Detached\DetachmentManager.h" />
+    <ClInclude Include="Speckle\Serialise\Detached\Storage\DetachedMemoryStore.h" />
+    <ClInclude Include="Speckle\Serialise\Detached\Storage\DetachedObjectStore.h" />
    <ClInclude Include="Speckle\Serialise\JSBase\JSBaseTransport.h" />
    <ClInclude Include="Speckle\SpeckleResource.h" />
    <ClInclude Include="Speckle\Utility\Exception.h" />
@@ -68,8 +82,12 @@
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="Speckle\Database\AccountDatabase.cpp" />
+    <ClCompile Include="Speckle\Database\BIMElementDatabase.cpp" />
+    <ClCompile Include="Speckle\Database\Content\BIMRecord.cpp" />
    <ClCompile Include="Speckle\Database\Content\Record.cpp" />
-    <ClCompile Include="Speckle\Database\Identity\Link.cpp" />
+    <ClCompile Include="Speckle\Database\Identity\BIMLink.cpp" />
+    <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\ArchicadDBaseCore.cpp" />
+    <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\Element\ArchicadElementDBaseEngine.cpp" />
    <ClCompile Include="Speckle\Database\Storage\DocumentStore\DocumentStoreCore.cpp" />
    <ClCompile Include="Speckle\Environment\Addon.cpp" />
    <ClCompile Include="Speckle\Environment\Platform.cpp" />
@@ -86,10 +104,15 @@
    <ClCompile Include="Speckle\Interface\Browser\Bridge\Functions\GetBindingsMethodNames.cpp" />
    <ClCompile Include="Speckle\Interface\Browser\Bridge\Functions\GetCallResult.cpp" />
    <ClCompile Include="Speckle\Interface\Browser\Bridge\Functions\RunMethod.cpp" />
+    <ClCompile Include="Speckle\Primitive\Mesh\Mesh.cpp" />
    <ClCompile Include="Speckle\Record\Credentials\Account.cpp" />
    <ClCompile Include="Speckle\Record\Credentials\ServerInfo.cpp" />
    <ClCompile Include="Speckle\Record\Credentials\ServerMigration.cpp" />
    <ClCompile Include="Speckle\Record\Credentials\UserInfo.cpp" />
+    <ClCompile Include="Speckle\Record\Element\Element.cpp" />
+    <ClCompile Include="Speckle\Serialise\Detached\DetachedReference.cpp" />
+    <ClCompile Include="Speckle\Serialise\Detached\DetachedWrap.cpp" />
+    <ClCompile Include="Speckle\Serialise\Detached\DetachmentManager.cpp" />
    <ClCompile Include="Speckle\Serialise\JSBase\JSBaseTransport.cpp" />
    <ClCompile Include="Speckle\Utility\Guid.cpp" />
    <ClCompile Include="Speckle\Utility\Guid64.cpp" />
@@ -62,6 +62,27 @@
    <Filter Include="Speckle\Database\Storage\DocumentStore">
      <UniqueIdentifier>{c4146af8-d1a1-44cc-9810-cc8da1a705a8}</UniqueIdentifier>
    </Filter>
+    <Filter Include="Speckle\Record\Element">
+      <UniqueIdentifier>{728f7e85-53d8-4fe0-9994-394010324eb8}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Primitive">
+      <UniqueIdentifier>{896361f5-4195-4662-be29-9e8241cab17c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Primitive\Mesh">
+      <UniqueIdentifier>{87719e02-08cb-466e-a01b-66fdbb278efe}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Database\Storage\ArchicadDBase">
+      <UniqueIdentifier>{c99c6ba7-cdb5-4182-9df9-debe5559b460}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Database\Storage\ArchicadDBase\Element">
+      <UniqueIdentifier>{93db2ed5-fd21-4ed1-86ee-f549682f66a5}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Serialise\Detached">
+      <UniqueIdentifier>{e9aec552-0aa8-4193-867d-69febdf93139}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Speckle\Serialise\Detached\Storage">
+      <UniqueIdentifier>{cb77e795-e8d8-4e31-9773-dd32beb694d3}</UniqueIdentifier>
+    </Filter>
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="Speckle\Environment\Addon.h">
@@ -202,6 +223,48 @@
    <ClInclude Include="Speckle\Version.h">
      <Filter>Speckle</Filter>
    </ClInclude>
+    <ClInclude Include="Speckle\Record\Element\Element.h">
+      <Filter>Speckle\Record\Element</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Primitive\Mesh\Mesh.h">
+      <Filter>Speckle\Primitive\Mesh</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\ArchicadDBaseCore.h">
+      <Filter>Speckle\Database\Storage\ArchicadDBase</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\Storage\ArchicadDBase\Element\ArchicadElementDBaseEngine.h">
+      <Filter>Speckle\Database\Storage\ArchicadDBase\Element</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\BIMElementDatabase.h">
+      <Filter>Speckle\Database</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\Content\BIMRecord.h">
+      <Filter>Speckle\Database\Content</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\Identity\BIMIndex.h">
+      <Filter>Speckle\Database\Identity</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\Identity\BIMLink.h">
+      <Filter>Speckle\Database\Identity</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Database\Identity\BIMRecordID.h">
+      <Filter>Speckle\Database\Identity</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Serialise\Detached\DetachedReference.h">
+      <Filter>Speckle\Serialise\Detached</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Serialise\Detached\DetachedWrap.h">
+      <Filter>Speckle\Serialise\Detached</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Serialise\Detached\DetachmentManager.h">
+      <Filter>Speckle\Serialise\Detached</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Serialise\Detached\Storage\DetachedMemoryStore.h">
+      <Filter>Speckle\Serialise\Detached\Storage</Filter>
+    </ClInclude>
+    <ClInclude Include="Speckle\Serialise\Detached\Storage\DetachedObjectStore.h">
+      <Filter>Speckle\Serialise\Detached\Storage</Filter>
+    </ClInclude>
  </ItemGroup>
  <ItemGroup>
    <ClCompile Include="Speckle\Environment\Addon.cpp">
@@ -252,9 +315,6 @@
    <ClCompile Include="Speckle\Utility\Guid64.cpp">
      <Filter>Speckle\Utility</Filter>
    </ClCompile>
-    <ClCompile Include="Speckle\Database\Identity\Link.cpp">
-      <Filter>Speckle\Database\Identity</Filter>
-    </ClCompile>
    <ClCompile Include="Speckle\Database\AccountDatabase.cpp">
      <Filter>Speckle\Database</Filter>
    </ClCompile>
@@ -285,6 +345,36 @@
    <ClCompile Include="Speckle\Event\Type\ProjectEvent.cpp">
      <Filter>Speckle\Event\Type</Filter>
    </ClCompile>
+    <ClCompile Include="Speckle\Record\Element\Element.cpp">
+      <Filter>Speckle\Record\Element</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Primitive\Mesh\Mesh.cpp">
+      <Filter>Speckle\Primitive\Mesh</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\ArchicadDBaseCore.cpp">
+      <Filter>Speckle\Database\Storage\ArchicadDBase</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Database\Storage\ArchicadDBase\Element\ArchicadElementDBaseEngine.cpp">
+      <Filter>Speckle\Database\Storage\ArchicadDBase\Element</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Database\BIMElementDatabase.cpp">
+      <Filter>Speckle\Database</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Database\Content\BIMRecord.cpp">
+      <Filter>Speckle\Database\Content</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Database\Identity\BIMLink.cpp">
+      <Filter>Speckle\Database\Identity</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Serialise\Detached\DetachedReference.cpp">
+      <Filter>Speckle\Serialise\Detached</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Serialise\Detached\DetachedWrap.cpp">
+      <Filter>Speckle\Serialise\Detached</Filter>
+    </ClCompile>
+    <ClCompile Include="Speckle\Serialise\Detached\DetachmentManager.cpp">
+      <Filter>Speckle\Serialise\Detached</Filter>
+    </ClCompile>
  </ItemGroup>
  <ItemGroup>
    <Text Include="Speckle\CMakeLists.txt">
Author	SHA1	Message	Date
oguzhankoral	77645fbea4	Batch sample	2024-10-02 18:17:13 +03:00
Ralph Wessel	cc034191b4	Updated with GetSendSettings	2024-10-02 12:54:48 +01:00
Ralph Wessel	a6911fad1c	Added GetSendSettings binding	2024-10-02 10:09:28 +01:00
Ralph Wessel	fdf371732b	Updated serialisation for send objects	2024-10-02 09:30:53 +01:00
Ralph Wessel	e9f8e86f95	Dummy information in SendObject	2024-10-01 18:58:50 +01:00
Ralph Wessel	8eae1e9967	Updated VS projects	2024-10-01 18:24:33 +01:00
Ralph Wessel	8ed2abea04	Implemented skeleton of SendObject	2024-10-01 18:21:30 +01:00
Ralph Wessel	e148094c81	ModelCardDatabase can retrieve a card by ID Added numerous Send argument classes: - ConversionResult (incomplete) - SendError - SendObject - SendViaBrowserArgs (incomplete) Send method looks up model card and account details, constructs send arguments AccountDatabase can find an account by ID or server URL Added DetachedMemoryStore	2024-10-01 17:24:59 +01:00
Ralph Wessel	deee1e80c5	Added classes for managing detached objects: - DetachmentManager: Manages detached objects during (de)serialisation - DetachedWrap: Wrapper for detached objects, generating references on demand from serialised data - DetachedReference: Wrapper for representation of wrapped objects with a reference - DetachedObjectStore: Interface for filing/retrieving detached objects in storage	2024-09-30 10:50:24 +01:00
Ralph Wessel	4c8a2237bf	Removed testing code	2024-09-26 13:28:14 +01:00
Ralph Wessel	5abc831473	Implemented Archicad element database functionality: - Retrieving the database from the Project - Gettting selected elements - Getting an element from an index/link	2024-09-26 13:05:22 +01:00
Ralph Wessel	b8d952c9a3	Updated Send method to trigger a browser event rather than throwing an exception Added new resources	2024-09-25 13:29:33 +01:00
Ralph Wessel	7baedf707a	Updated VS projects	2024-09-24 22:29:40 +01:00
Ralph Wessel	4dd0a1b1b6	Added skeleton BIM database, element, collection and Mesh classes to support sending model data	2024-09-24 21:50:28 +01:00
Ralph Wessel	29ece2282f	Added DocumentStoreEngine::getUniqueID Added ModelCardDatabase::getStoreID	2024-09-23 16:01:35 +01:00
Ralph Wessel	f0fc7e8fec	Merge tag '0.2.4' into develop 0.2.4	2024-09-23 14:10:34 +01:00
Ralph Wessel	8dceee52f2	Merge branch 'release/0.2.4'	2024-09-23 14:10:34 +01:00