diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
index 534eb0d2..d4fd32c9 100644
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "clangsharppinvokegenerator": {
-      "version": "15.0.2",
+      "version": "16.0.0",
       "commands": [
         "ClangSharpPInvokeGenerator"
       ]
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index 2a3c0c88..e27cd24c 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -2,6 +2,7 @@ name: Nightly-Build
 
 env:
   TILEDB_NIGHTLY_BUILD: 1
+  VCPKG_BINARY_SOURCES: 'clear;x-gha,readwrite'
 
 on:
   schedule:
@@ -19,15 +20,16 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
         include:
-          - BOOTSTRAP: ../bootstrap --enable-s3 --enable-serialization --force-build-all-deps
+          - BOOTSTRAP: ../bootstrap --enable-s3 --enable-serialization --force-build-all-deps --enable-vcpkg
           - os: ubuntu-latest
             platform: linux-x86_64
           - os: macos-latest
             platform: macos-x86_64
           - os: windows-latest
             platform: windows-x86_64
-            BOOTSTRAP: ../bootstrap.ps1 -EnableS3 -EnableSerialization -EnableBuildDeps
-        tag: [release-2.15, dev]
+            BOOTSTRAP: ../bootstrap.ps1 -EnableS3 -EnableSerialization -EnableBuildDeps -EnableVcpkg
+          - tag: dev
+        tag: [release-2.17, dev]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout TileDB
@@ -35,7 +37,12 @@ jobs:
         with:
           repository: TileDB-Inc/TileDB
           ref: ${{ matrix.tag }}
-
+      - name: Export GitHub Actions cache variables
+        uses: actions/github-script@v6
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
       - name: Build TileDB
         run: |
           mkdir -p build
@@ -45,7 +52,7 @@ jobs:
           cmake --build . --config Release --target install-tiledb
           cd ../
           mkdir -p artifacts/${{ matrix.platform }}
-          mv dist/* artifacts/${{ matrix.platform }}
+          mv build/dist/* artifacts/${{ matrix.platform }}
 
       # We combine the binaries of the many platforms per tag by uploading them to the same artifact.
       - name: Upload native artifacts
@@ -53,13 +60,14 @@ jobs:
         with:
           name: tiledb-native-${{ matrix.tag }}
           path: artifacts/
+          retention-days: 1
 
   Pack-NuGet:
     needs: Build-Native
     strategy:
       fail-fast: false
       matrix:
-        tag: [release-2.15, dev]
+        tag: [release-2.17, dev]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout TileDB-CSharp
@@ -91,6 +99,7 @@ jobs:
         with:
           name: tiledb-nuget-${{ matrix.tag }}
           path: scripts/nuget/packages/
+          retention-days: 5
 
   Test-NuGet:
     needs: Pack-NuGet
@@ -98,7 +107,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        tag: [release-2.15, dev]
+        tag: [release-2.17, dev]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout TileDB-CSharp
diff --git a/.github/workflows/tiledb-csharp.yml b/.github/workflows/tiledb-csharp.yml
index a19c666e..1b8354eb 100644
--- a/.github/workflows/tiledb-csharp.yml
+++ b/.github/workflows/tiledb-csharp.yml
@@ -2,13 +2,35 @@ name: CI
 
 on:
   push:
-    branches: [ main ]
+    branches: [ main, 'release/*' ]
   pull_request:
-    branches: [ main ]
+    branches: [ main, 'release/*' ]
   workflow_dispatch:
   workflow_call:
 
 jobs:
+  Validate-Package:
+    runs-on: ubuntu-latest
+    steps:
+      # Checks out repository
+      - uses: actions/checkout@v3
+
+      - name: Remove existing .NET versions
+        shell: bash
+        run: |
+          rm -rf $DOTNET_ROOT
+
+      - name: Set up .NET SDK from global.json
+        uses: actions/setup-dotnet@v3
+
+      - name: Display .NET versions
+        run: dotnet --info
+
+      # Package validation runs as part of packing.
+      - name: Dotnet pack for TileDB.CSharp
+        run: |
+          dotnet pack -c Release sources/TileDB.CSharp
+
   Run-Tests:
     strategy:
       fail-fast: false
diff --git a/Directory.Packages.props b/Directory.Packages.props
index e40cd2db..cb1d412d 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <TileDBNativePackageName>TileDB.Native</TileDBNativePackageName>
-    <TileDBNativePackageVersion>[2.15.0,2.16.0)</TileDBNativePackageVersion>
+    <TileDBNativePackageVersion>[2.17.0,2.18.0)</TileDBNativePackageVersion>
 
     <!-- The DevelopmentBuild property switches to the locally built native packages.
     They have a different name to avoid publishing them by mistake, and to
@@ -25,12 +25,12 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="$(TileDBNativePackageName)" Version="$(TileDBNativePackageVersion)" />
-    <PackageVersion Include="GitHubActionsTestLogger" Version="2.0.1" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
-    <PackageVersion Include="MSTest.TestAdapter" Version="3.0.2" />
-    <PackageVersion Include="MSTest.TestFramework" Version="3.0.2" />
-    <PackageVersion Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
-    <GlobalPackageReference Include="SonarAnalyzer.CSharp" Version="8.51.0.59060" />
+    <PackageVersion Include="GitHubActionsTestLogger" Version="2.3.2" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.6.2" />
+    <PackageVersion Include="MSTest.TestAdapter" Version="3.0.4" />
+    <PackageVersion Include="MSTest.TestFramework" Version="3.0.4" />
+    <PackageVersion Include="coverlet.collector" Version="6.0.0" PrivateAssets="all" />
+    <GlobalPackageReference Include="SonarAnalyzer.CSharp" Version="9.3.0.71466" />
     <GlobalPackageReference Include="DotNet.ReproducibleBuilds" Version="1.1.1" />
   </ItemGroup>
 </Project>
diff --git a/docs/obsoletions.md b/docs/obsoletions.md
index 5315c7c9..8893f3a2 100644
--- a/docs/obsoletions.md
+++ b/docs/obsoletions.md
@@ -7,6 +7,7 @@ Following [the deprecation policy of TileDB Embedded][core-deprecation], obsolet
 |Diagnostic codes|Deprecated in version|Removed in version|
 |----------------|---------------------|------------------|
 |[`TILEDB0001`](#TILEDB0001) …[`TILEDB0011`](#TILEDB0011)|5.3.0|5.5.0|
+|[`TILEDB0012`](#TILEDB0012) …[`TILEDB0012`](#TILEDB0012)|5.7.0|5.9.0|
 
 ## `TILEDB0001` - Enum value names that start with `TILEDB_` were replaced with C#-friendly names.
 
@@ -299,4 +300,23 @@ Some of these methods were renamed or had their signature changed (for example t
 
 Instead of setting ranges and subarrays on the `Query`, create and configure a `Subarray` object, and assign it to the query using the `Query.SetSubarray` method.
 
+## `TILEDB0012` - Members of the `TileDB.Interop` namespace will become internal in a future version and should not be used by user code.
+
+<a name="TILEDB0012"></a>
+
+Some APIs in the `TileDB.Interop` namespace that were inadvertently removed in version 5.3.0 were reintroduced in version 5.7.0. They are marked as obsolete and hidden from IntelliSense and will be removed from the public API for good in version 5.9.0. They were also reintroduced in patch releases 5.3.1 and 5.4.1, obsoleted under the [`TILEDB0003`](#TILEDB0003) code.
+
+### Version introduced
+
+5.7.0
+
+### Recommended action
+
+The obsoleted APIs fall into the following categories:
+
+- The `MarshaledString` and `MarshaledStringOut` types are used to help convert strings from and to ASCII and pass them to native code. If you are using them in user code for native code interop, you should use .NET's [built-in P/Invoke](https://learn.microsoft.com/en-us/dotnet/standard/native-interop/charset) marshaling instead. For other kinds of encoding conversions, you should use APIs from the [`System.Text.Encoding`](https://learn.microsoft.com/en-us/dotnet/api/system.text.encoding) class.
+- The `__sFile` and `LibC` types have no members and there is no reason to use them anyway.
+- The types that derive from `SafeHandle` are used to safely manage the lifetime of native TileDB objects. With the APIs in the `TileDB.CSharp` namespace providing broad coverage of TileDB's functionalities while also being safer and easier to sue, these types provide limited utility. You should use the APIs in the `TileDB.CSharp` namespace instead.
+- Types with the name `tiledb_***_t` were made public again only to support the APIs of the safe handles above. They have little other use on their own. You should use APIs in the `TileDB.CSharp` namespace instead.
+
 [core-deprecation]: https://github.com/TileDB-Inc/TileDB/blob/dev/doc/policy/api_changes.md
diff --git a/examples/TileDB.CSharp.Example/ExampleIncompleteQuery.cs b/examples/TileDB.CSharp.Example/ExampleIncompleteQuery.cs
index 15f7fa18..03d4a0ac 100644
--- a/examples/TileDB.CSharp.Example/ExampleIncompleteQuery.cs
+++ b/examples/TileDB.CSharp.Example/ExampleIncompleteQuery.cs
@@ -51,7 +51,7 @@ from b in Enumerable.Range(1, 10)
             {
                 arrayWrite.Open(QueryType.Write);
 
-                var queryWrite = new Query(Ctx, arrayWrite);
+                var queryWrite = new Query(arrayWrite);
                 queryWrite.SetLayout(LayoutType.Unordered);
                 queryWrite.SetDataBuffer("rows", rowsData);
                 queryWrite.SetDataBuffer("cols", colsData);
@@ -73,7 +73,7 @@ private static void ReadArray()
             using (var arrayRead = new Array(Ctx, ArrayPath))
             {
                 arrayRead.Open(QueryType.Read);
-                var queryRead = new Query(Ctx, arrayRead);
+                var queryRead = new Query(arrayRead);
                 queryRead.SetLayout(LayoutType.Unordered);
 
                 queryRead.SetDataBuffer("rows", rowsRead);
diff --git a/examples/TileDB.CSharp.Example/ExampleIncompleteQueryStringDimensions.cs b/examples/TileDB.CSharp.Example/ExampleIncompleteQueryStringDimensions.cs
index e0e54ed1..fe81fae9 100644
--- a/examples/TileDB.CSharp.Example/ExampleIncompleteQueryStringDimensions.cs
+++ b/examples/TileDB.CSharp.Example/ExampleIncompleteQueryStringDimensions.cs
@@ -43,7 +43,7 @@ private static void WriteArray()
             {
                 arrayWrite.Open(QueryType.Write);
 
-                var queryWrite = new Query(Ctx, arrayWrite);
+                var queryWrite = new Query(arrayWrite);
                 queryWrite.SetLayout(LayoutType.Unordered);
                 queryWrite.SetDataBuffer("rows", rowsData);
                 queryWrite.SetOffsetsBuffer("rows", rowsOffsets);
@@ -62,7 +62,7 @@ private static void ReadArray()
             using (var arrayRead = new Array(Ctx, ArrayPath))
             {
                 arrayRead.Open(QueryType.Read);
-                var queryRead = new Query(Ctx, arrayRead);
+                var queryRead = new Query(arrayRead);
                 queryRead.SetLayout(LayoutType.Unordered);
                 var subarray = new Subarray(arrayRead);
                 subarray.AddRange("rows", "a", "eeeee");
diff --git a/examples/TileDB.CSharp.Example/ExampleIncompleteQueryVariableSize.cs b/examples/TileDB.CSharp.Example/ExampleIncompleteQueryVariableSize.cs
index 1921293c..f998d1d0 100644
--- a/examples/TileDB.CSharp.Example/ExampleIncompleteQueryVariableSize.cs
+++ b/examples/TileDB.CSharp.Example/ExampleIncompleteQueryVariableSize.cs
@@ -37,7 +37,7 @@ private static void WriteArray()
             using (var array_write = new Array(Ctx, ArrayPath))
             {
                 array_write.Open(QueryType.Write);
-                var query_write = new Query(Ctx, array_write);
+                var query_write = new Query(array_write);
                 query_write.SetLayout(LayoutType.Unordered);
                 query_write.SetDataBuffer("rows", dim1_data_buffer);
                 query_write.SetDataBuffer("cols", dim2_data_buffer);
@@ -58,7 +58,7 @@ private static void ReadArray()
             using (var array_read = new Array(Ctx, ArrayPath))
             {
                 array_read.Open(QueryType.Read);
-                var query_read = new Query(Ctx, array_read);
+                var query_read = new Query(array_read);
                 query_read.SetLayout(LayoutType.Unordered);
                 query_read.SetDataBuffer("rows", dim1_data_buffer_read);
                 query_read.SetDataBuffer("cols", dim2_data_buffer_read);
diff --git a/examples/TileDB.CSharp.Example/ExampleQuery.cs b/examples/TileDB.CSharp.Example/ExampleQuery.cs
index 05b65e84..5b06add9 100644
--- a/examples/TileDB.CSharp.Example/ExampleQuery.cs
+++ b/examples/TileDB.CSharp.Example/ExampleQuery.cs
@@ -34,7 +34,7 @@ private static void WriteArray()
             using (var array_write = new Array(Ctx, ArrayPath))
             {
                 array_write.Open(QueryType.Write);
-                var query_write = new Query(Ctx, array_write);
+                var query_write = new Query(array_write);
                 query_write.SetLayout(LayoutType.Unordered);
                 query_write.SetDataBuffer("rows", dim1_data_buffer);
                 query_write.SetDataBuffer("cols", dim2_data_buffer);
@@ -53,7 +53,7 @@ private static void ReadArray()
             using (var array_read = new Array(Ctx, ArrayPath))
             {
                 array_read.Open(QueryType.Read);
-                var query_read = new Query(Ctx, array_read);
+                var query_read = new Query(array_read);
                 query_read.SetLayout(LayoutType.RowMajor);
                 query_read.SetDataBuffer("rows", dim1_data_buffer_read);
                 query_read.SetDataBuffer("cols", dim2_data_buffer_read);
diff --git a/examples/TileDB.CSharp.Example/ExampleWritingDenseGlobal.cs b/examples/TileDB.CSharp.Example/ExampleWritingDenseGlobal.cs
index ab82ca3b..6f135def 100644
--- a/examples/TileDB.CSharp.Example/ExampleWritingDenseGlobal.cs
+++ b/examples/TileDB.CSharp.Example/ExampleWritingDenseGlobal.cs
@@ -29,7 +29,7 @@ private static void WriteArray()
             using var array = new Array(Ctx, ArrayPath);
             array.Open(QueryType.Write);
 
-            using var queryWrite = new Query(Ctx, array, QueryType.Write);
+            using var queryWrite = new Query(array, QueryType.Write);
             queryWrite.SetLayout(LayoutType.GlobalOrder);
             // Slice rows 1-4, columns 1-2 for a total of 8 cells
             using var subarray = new Subarray(array);
@@ -56,7 +56,7 @@ private static void ReadArray()
         {
             using var array = new Array(Ctx, ArrayPath);
             array.Open(QueryType.Read);
-            using var readQuery = new Query(Ctx, array, QueryType.Read);
+            using var readQuery = new Query(array, QueryType.Read);
             using var subarray = new Subarray(array);
             subarray.SetSubarray(1, 4, 1, 4);
             readQuery.SetSubarray(subarray);
diff --git a/examples/TileDB.CSharp.Example/ExampleWritingSparseGlobal.cs b/examples/TileDB.CSharp.Example/ExampleWritingSparseGlobal.cs
index ee5b4bba..06d2854c 100644
--- a/examples/TileDB.CSharp.Example/ExampleWritingSparseGlobal.cs
+++ b/examples/TileDB.CSharp.Example/ExampleWritingSparseGlobal.cs
@@ -29,7 +29,7 @@ private static void WriteArray()
         {
             using var array = new Array(Ctx, ArrayPath);
             array.Open(QueryType.Write);
-            using var queryWrite = new Query(Ctx, array, QueryType.Write);
+            using var queryWrite = new Query(array, QueryType.Write);
             queryWrite.SetLayout(LayoutType.GlobalOrder);
 
             // Coordinates for global order writes must be provided in-order
@@ -57,7 +57,7 @@ private static void ReadArray()
         {
             using var array = new Array(Ctx, ArrayPath);
             array.Open(QueryType.Read);
-            using var readQuery = new Query(Ctx, array, QueryType.Read);
+            using var readQuery = new Query(array, QueryType.Read);
             using var subarray = new Subarray(array);
             subarray.SetSubarray(1, 4, 1, 4);
             readQuery.SetSubarray(subarray);
diff --git a/examples/TileDB.CSharp.Example/TileDB.CSharp.Example.csproj b/examples/TileDB.CSharp.Example/TileDB.CSharp.Example.csproj
index 8253ac83..1d733237 100644
--- a/examples/TileDB.CSharp.Example/TileDB.CSharp.Example.csproj
+++ b/examples/TileDB.CSharp.Example/TileDB.CSharp.Example.csproj
@@ -4,7 +4,7 @@
     <OutputType>Exe</OutputType>
     <RollForward>Major</RollForward>
     <RootNamespace>TileDB.CSharp.Examples</RootNamespace>
-    <TargetFrameworks>net5.0;net6.0</TargetFrameworks>
+    <TargetFrameworks>net5.0;net6.0;net7.0</TargetFrameworks>
     <UseCurrentRuntimeIdentifier>true</UseCurrentRuntimeIdentifier>
   </PropertyGroup>
 
diff --git a/global.json b/global.json
index 4347eeb3..93ffc6c6 100644
--- a/global.json
+++ b/global.json
@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "7.0.200"
+    "version": "7.0.305"
   }
 }
diff --git a/scripts/generate-bindings/GenerateBindings.proj b/scripts/generate-bindings/GenerateBindings.proj
index 08046547..6d8ec172 100644
--- a/scripts/generate-bindings/GenerateBindings.proj
+++ b/scripts/generate-bindings/GenerateBindings.proj
@@ -17,11 +17,16 @@
     <ConfigOption Include="multi-file" />
     <InputFile Include="tiledb/tiledb_experimental.h" />
     <TraversePaths Include="$(InputDir)/**/*.h" />
+    <RemapHandleType Include="attribute" />
     <RemapHandleType Include="buffer" />
+    <RemapHandleType Include="buffer_list" />
     <RemapHandleType Include="config" />
     <RemapHandleType Include="config_iter" />
     <RemapHandleType Include="ctx" />
+    <RemapHandleType Include="dimension" />
     <RemapHandleType Include="dimension_label" />
+    <RemapHandleType Include="domain" />
+    <RemapHandleType Include="enumeration" />
     <RemapHandleType Include="error" />
     <RemapHandleType Include="filter" />
     <RemapHandleType Include="filter_list" />
@@ -31,10 +36,11 @@
     <RemapHandleType Include="vfs_fh" />
     <Remap Include="@(RemapHandleType->'tiledb_%(Identity)_handle_t=tiledb_%(Identity)_t')" />
     <Remap Include="tiledb_experimental_query_status_details_t=tiledb_query_status_details_t" />
+    <ExcludeDump Include="array_schema" />
     <ExcludeDump Include="attribute" />
-    <ExcludeDump Include="domain" />
     <ExcludeDump Include="dimension" />
-    <ExcludeDump Include="array_schema" />
+    <ExcludeDump Include="domain" />
+    <ExcludeDump Include="enumeration" />
     <ExcludeDump Include="stats" />
     <ExcludeDump Include="stats_raw" />
     <ExcludeDump Include="fragment_info" />
diff --git a/sources/TileDB.CSharp/Array.cs b/sources/TileDB.CSharp/Array.cs
index f841cc17..9697e6f1 100644
--- a/sources/TileDB.CSharp/Array.cs
+++ b/sources/TileDB.CSharp/Array.cs
@@ -5,6 +5,9 @@
 using TileDB.CSharp.Marshalling;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ArrayHandle = TileDB.CSharp.Marshalling.SafeHandles.ArrayHandle;
+using ArraySchemaHandle = TileDB.CSharp.Marshalling.SafeHandles.ArraySchemaHandle;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/ArrayMetadata.cs b/sources/TileDB.CSharp/ArrayMetadata.cs
index 1ab7e3d6..0e7b1ef3 100644
--- a/sources/TileDB.CSharp/ArrayMetadata.cs
+++ b/sources/TileDB.CSharp/ArrayMetadata.cs
@@ -31,7 +31,7 @@ public ArrayMetadata(Array array)
         public void PutMetadata<T>(string key, T[] data) where T : struct
         {
             var tiledb_datatype = (tiledb_datatype_t)EnumUtil.TypeToDataType(typeof(T));
-            put_metadata<T>(key, data, tiledb_datatype, (uint)data.Length);
+            put_metadata(key, data, tiledb_datatype);
         }
 
         /// <inheritdoc cref="Array.PutMetadata{T}(string, T)"/>
@@ -44,10 +44,8 @@ public void PutMetadata<T>(string key, T v) where T : struct
         /// <inheritdoc cref="Array.PutMetadata(string, string)"/>
         public void PutMetadata(string key, string value)
         {
-            var tiledb_datatype = tiledb_datatype_t.TILEDB_STRING_ASCII;
-            var data = Encoding.ASCII.GetBytes(value);
-            var val_num = (uint)data.Length;
-            put_metadata<byte>(key, data, tiledb_datatype, val_num);
+            var data = Encoding.UTF8.GetBytes(value);
+            put_metadata(key, data, tiledb_datatype_t.TILEDB_STRING_UTF8);
         }
 
         /// <inheritdoc cref="Array.DeleteMetadata"/>
@@ -73,8 +71,8 @@ public T[] GetMetadata<T>(string key) where T : struct
         /// <inheritdoc cref="Array.GetMetadata(string)"/>
         public string GetMetadata(string key)
         {
-            var (_, byte_array, _, _) = get_metadata(key);
-            return MarshaledStringOut.GetString(byte_array);
+            var (_, byte_array, datatype, _) = get_metadata(key);
+            return MarshaledStringOut.GetString(byte_array, (DataType)datatype);
         }
 
         /// <inheritdoc cref="Array.MetadataNum"/>
@@ -229,7 +227,7 @@ public bool IsReadOnly
         /// <inheritdoc cref="IDictionary{TKey, TValue}.Add"/>
         public void Add(string key, byte[] value)
         {
-            put_metadata<byte>(key, value, tiledb_datatype_t.TILEDB_UINT8, (uint)value.Length);
+            put_metadata(key, value, tiledb_datatype_t.TILEDB_UINT8);
         }
 
         /// <inheritdoc cref="ICollection{T}.Add"/>
@@ -300,7 +298,7 @@ IEnumerator IEnumerable.GetEnumerator()
             throw new NotImplementedException();
         }
 
-        private void put_metadata<T>(string key, T[] value, tiledb_datatype_t tiledb_datatype, uint value_num) where T : struct
+        private void put_metadata<T>(string key, T[] value, tiledb_datatype_t tiledb_datatype) where T : struct
         {
             ErrorHandling.ThrowIfManagedType<T>();
             if (string.IsNullOrEmpty(key) || value.Length == 0)
@@ -312,7 +310,7 @@ private void put_metadata<T>(string key, T[] value, tiledb_datatype_t tiledb_dat
             using var ctxHandle = ctx.Handle.Acquire();
             using var arrayHandle = _array.Handle.Acquire();
             fixed (T* dataPtr = &value[0])
-                ctx.handle_error(Methods.tiledb_array_put_metadata(ctxHandle, arrayHandle, ms_key, tiledb_datatype, value_num, dataPtr));
+                ctx.handle_error(Methods.tiledb_array_put_metadata(ctxHandle, arrayHandle, ms_key, tiledb_datatype, (uint)value.Length, dataPtr));
         }
 
         private (string key, byte[] data, tiledb_datatype_t tiledb_datatype, uint value_num) get_metadata(string key)
diff --git a/sources/TileDB.CSharp/ArraySchema.cs b/sources/TileDB.CSharp/ArraySchema.cs
index f7bc90ce..a7861918 100644
--- a/sources/TileDB.CSharp/ArraySchema.cs
+++ b/sources/TileDB.CSharp/ArraySchema.cs
@@ -3,6 +3,10 @@
 using System.Runtime.CompilerServices;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ArraySchemaHandle = TileDB.CSharp.Marshalling.SafeHandles.ArraySchemaHandle;
+using FilterListHandle = TileDB.CSharp.Marshalling.SafeHandles.FilterListHandle;
+using DomainHandle = TileDB.CSharp.Marshalling.SafeHandles.DomainHandle;
+using AttributeHandle = TileDB.CSharp.Marshalling.SafeHandles.AttributeHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/ArraySchemaEvolution.cs b/sources/TileDB.CSharp/ArraySchemaEvolution.cs
index 7611967d..76040185 100644
--- a/sources/TileDB.CSharp/ArraySchemaEvolution.cs
+++ b/sources/TileDB.CSharp/ArraySchemaEvolution.cs
@@ -1,6 +1,7 @@
 using System;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ArraySchemaEvolutionHandle = TileDB.CSharp.Marshalling.SafeHandles.ArraySchemaEvolutionHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/Attribute.cs b/sources/TileDB.CSharp/Attribute.cs
index b8ce300d..98f478f6 100644
--- a/sources/TileDB.CSharp/Attribute.cs
+++ b/sources/TileDB.CSharp/Attribute.cs
@@ -2,8 +2,10 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
-using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using TileDB.CSharp.Marshalling.SafeHandles;
+using AttributeHandle = TileDB.CSharp.Marshalling.SafeHandles.AttributeHandle;
+using FilterListHandle = TileDB.CSharp.Marshalling.SafeHandles.FilterListHandle;
 
 namespace TileDB.CSharp
 {
@@ -290,7 +292,7 @@ public string FillValue()
                 throw new NotSupportedException("Attribute.FillValue, please use FillValue<T> for non-string attribute!");
             }
             var fill_bytes = get_fill_value();
-            return MarshaledStringOut.GetString(fill_bytes);
+            return MarshaledStringOut.GetString(fill_bytes, datatype);
         }
 
         /// <summary>
@@ -395,7 +397,7 @@ public string FillValueNullable()
                 throw new NotSupportedException("Attribute.FillValueNullable, please use fill_value<T> for non-string attribute!");
             }
             var (fill_bytes, _) = get_fill_value_nullable();
-            return MarshaledStringOut.GetString(fill_bytes);
+            return MarshaledStringOut.GetString(fill_bytes, datatype);
         }
 
         /// <summary>
diff --git a/sources/TileDB.CSharp/Config.cs b/sources/TileDB.CSharp/Config.cs
index bbeed7d4..92eb2531 100644
--- a/sources/TileDB.CSharp/Config.cs
+++ b/sources/TileDB.CSharp/Config.cs
@@ -2,6 +2,7 @@
 using System.Text;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/ConfigIterator.cs b/sources/TileDB.CSharp/ConfigIterator.cs
index 0b570668..6e56e36b 100644
--- a/sources/TileDB.CSharp/ConfigIterator.cs
+++ b/sources/TileDB.CSharp/ConfigIterator.cs
@@ -1,6 +1,8 @@
 using System;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
+using ConfigIteratorHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigIteratorHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/Context.cs b/sources/TileDB.CSharp/Context.cs
index 8d49abc7..d633ba85 100644
--- a/sources/TileDB.CSharp/Context.cs
+++ b/sources/TileDB.CSharp/Context.cs
@@ -7,6 +7,8 @@
 using System.Text;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ContextHandle = TileDB.CSharp.Marshalling.SafeHandles.ContextHandle;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
 
 namespace TileDB.CSharp
 {
@@ -16,7 +18,6 @@ namespace TileDB.CSharp
     public sealed unsafe class Context : IDisposable
     {
         private readonly ContextHandle _handle;
-        private readonly Config _config;
 
         private bool IsDefault { get; init; }
 
@@ -26,7 +27,7 @@ public sealed unsafe class Context : IDisposable
         public Context()
         {
             _handle = ContextHandle.Create();
-            _config = new Config();
+            SetDefaultTags();
         }
 
         /// <summary>
@@ -36,7 +37,12 @@ public Context()
         public Context(Config config)
         {
             _handle = ContextHandle.Create(config.Handle);
-            _config = config;
+            SetDefaultTags();
+        }
+
+        private void SetDefaultTags()
+        {
+            SetTag("x-tiledb-api-language", "csharp");
         }
 
         /// <summary>
diff --git a/sources/TileDB.CSharp/CoreUtil.cs b/sources/TileDB.CSharp/CoreUtil.cs
index b00a56fc..8026bcbe 100644
--- a/sources/TileDB.CSharp/CoreUtil.cs
+++ b/sources/TileDB.CSharp/CoreUtil.cs
@@ -2,18 +2,21 @@
 using System.Text;
 using System.Collections.Generic;
 using TileDB.Interop;
+using TileDB.CSharp.Marshalling;
 
 namespace TileDB.CSharp
 {
     /// <summary>
-    /// General utility functions.
+    /// Contains general utility functions.
     /// </summary>
     public static class CoreUtil
     {
         private static Version? _coreLibVersion;
 
+        private static string? _buildConfiguration;
+
         /// <summary>
-        /// Returns the version of TileDB Embedded.
+        /// Returns the version of the TileDB Embedded binary being used.
         /// </summary>
         public static Version GetCoreLibVersion()
         {
@@ -27,6 +30,24 @@ static unsafe Version GetVersion()
             }
         }
 
+        /// <summary>
+        /// Returns a string describing the build configuration of the TileDB Embedded binary being used.
+        /// </summary>
+        /// <remarks>
+        /// This method exposes the <c>tiledb_as_built_dump</c> function of the TileDB Embedded C API.
+        /// </remarks>
+        public static string GetBuildConfiguration()
+        {
+            return _buildConfiguration ??= Create();
+
+            static unsafe string Create()
+            {
+                using var resultHolder = new StringHandleHolder();
+                ErrorHandling.ThrowOnError(Methods.tiledb_as_built_dump(&resultHolder._handle));
+                return resultHolder.ToString();
+            }
+        }
+
         #region  Buffer
 
         /// <summary>
@@ -91,7 +112,7 @@ public static (byte[] data, ulong[] offsets) PackStringArray(string[] strarray,
                 }
                 else
                 {
-                    bytes_size = Encoding.ASCII.GetByteCount(strarray[i]);
+                    bytes_size = Encoding.UTF8.GetByteCount(strarray[i]);
                 }
                 totsize += bytes_size;
             }
@@ -119,7 +140,7 @@ public static (byte[] data, ulong[] offsets) PackStringArray(string[] strarray,
                 }
                 else
                 {
-                    bytes = Encoding.ASCII.GetBytes(strarray[i]);
+                    bytes = Encoding.UTF8.GetBytes(strarray[i]);
                 }
                 bytes.CopyTo(data, idx);
                 idx += bytes.Length;
diff --git a/sources/TileDB.CSharp/Dimension.cs b/sources/TileDB.CSharp/Dimension.cs
index aab689e8..009ffa6d 100644
--- a/sources/TileDB.CSharp/Dimension.cs
+++ b/sources/TileDB.CSharp/Dimension.cs
@@ -4,6 +4,8 @@
 using TileDB.CSharp.Marshalling;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using DimensionHandle = TileDB.CSharp.Marshalling.SafeHandles.DimensionHandle;
+using FilterListHandle = TileDB.CSharp.Marshalling.SafeHandles.FilterListHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/Domain.cs b/sources/TileDB.CSharp/Domain.cs
index 24a25f81..f23a3ea8 100644
--- a/sources/TileDB.CSharp/Domain.cs
+++ b/sources/TileDB.CSharp/Domain.cs
@@ -1,6 +1,8 @@
 using System;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using DomainHandle = TileDB.CSharp.Marshalling.SafeHandles.DomainHandle;
+using DimensionHandle = TileDB.CSharp.Marshalling.SafeHandles.DimensionHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/Enums.cs b/sources/TileDB.CSharp/Enums.cs
index 0922e99d..1d365eb2 100644
--- a/sources/TileDB.CSharp/Enums.cs
+++ b/sources/TileDB.CSharp/Enums.cs
@@ -73,7 +73,11 @@ public enum QueryStatus : uint
         /// <summary>
         /// The query is not initialized.
         /// </summary>
-        Uninitialized = tiledb_query_status_t.TILEDB_UNINITIALIZED
+        Uninitialized = tiledb_query_status_t.TILEDB_UNINITIALIZED,
+        /// <summary>
+        /// The query is initialized.
+        /// </summary>
+        Initialized = tiledb_query_status_t.TILEDB_INITIALIZED
     }
 
     /// <summary>
@@ -470,7 +474,11 @@ public enum FilterType : uint
         /// <summary>
         /// WebP filter.
         /// </summary>
-        Webp = tiledb_filter_type_t.TILEDB_FILTER_WEBP
+        Webp = tiledb_filter_type_t.TILEDB_FILTER_WEBP,
+        /// <summary>
+        /// Delta filter.
+        /// </summary>
+        Delta = tiledb_filter_type_t.TILEDB_FILTER_DELTA
     }
 
     public enum FilterOption : uint
@@ -501,7 +509,16 @@ public enum FilterOption : uint
         /// <remarks>
         /// Must be a <see cref="bool"/>.
         /// </remarks>
-        WebpLossless = tiledb_filter_option_t.TILEDB_WEBP_LOSSLESS
+        WebpLossless = tiledb_filter_option_t.TILEDB_WEBP_LOSSLESS,
+        /// <summary>
+        /// The type to reinterpret data prior to compression.
+        /// </summary>
+        /// <remarks>
+        /// Must be a <see cref="DataType"/>.
+        /// </remarks>
+        // Documentation of the C API says this is a uint8_t. In the C# API, DataType is a UInt32
+        // but passing a pointer to the latter as the former will work on little-endian systems.
+        CompressionReinterpretDatatype = tiledb_filter_option_t.TILEDB_COMPRESSION_REINTERPRET_DATATYPE
     }
 
     /// <summary>
diff --git a/sources/TileDB.CSharp/File.cs b/sources/TileDB.CSharp/File.cs
index 4a38e751..0d7df6e3 100644
--- a/sources/TileDB.CSharp/File.cs
+++ b/sources/TileDB.CSharp/File.cs
@@ -1,6 +1,7 @@
 using System.ComponentModel;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ArraySchemaHandle = TileDB.CSharp.Marshalling.SafeHandles.ArraySchemaHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/Filter.cs b/sources/TileDB.CSharp/Filter.cs
index ba866ec4..3f8fc57a 100644
--- a/sources/TileDB.CSharp/Filter.cs
+++ b/sources/TileDB.CSharp/Filter.cs
@@ -3,6 +3,7 @@
 using System.Runtime.InteropServices;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using FilterHandle = TileDB.CSharp.Marshalling.SafeHandles.FilterHandle;
 
 namespace TileDB.CSharp
 {
@@ -76,7 +77,8 @@ private void check_filter_option<T>(FilterOption filterOption)
                 (filterOption == FilterOption.ScaleFloatOffset && typeof(T) == typeof(double)) ||
                 (filterOption == FilterOption.WebpQuality && typeof(T) == typeof(float)) ||
                 (filterOption == FilterOption.WebpInputFormat && typeof(T) == typeof(WebpInputFormat)) ||
-                (filterOption == FilterOption.WebpLossless && typeof(T) == typeof(bool));
+                (filterOption == FilterOption.WebpLossless && typeof(T) == typeof(bool)) ||
+                (filterOption == FilterOption.CompressionReinterpretDatatype && typeof(T) == typeof(DataType));
 
             if (!ok)
             {
diff --git a/sources/TileDB.CSharp/FilterList.cs b/sources/TileDB.CSharp/FilterList.cs
index 89c4fa59..ec8e627b 100644
--- a/sources/TileDB.CSharp/FilterList.cs
+++ b/sources/TileDB.CSharp/FilterList.cs
@@ -1,6 +1,8 @@
 using System;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using FilterHandle = TileDB.CSharp.Marshalling.SafeHandles.FilterHandle;
+using FilterListHandle = TileDB.CSharp.Marshalling.SafeHandles.FilterListHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/FragmentInfo.cs b/sources/TileDB.CSharp/FragmentInfo.cs
index 8eeeb3dd..e76cdadd 100644
--- a/sources/TileDB.CSharp/FragmentInfo.cs
+++ b/sources/TileDB.CSharp/FragmentInfo.cs
@@ -3,6 +3,8 @@
 using TileDB.CSharp.Marshalling;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ArraySchemaHandle = TileDB.CSharp.Marshalling.SafeHandles.ArraySchemaHandle;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/Group.cs b/sources/TileDB.CSharp/Group.cs
index 1ee4ab71..af2c3875 100644
--- a/sources/TileDB.CSharp/Group.cs
+++ b/sources/TileDB.CSharp/Group.cs
@@ -1,6 +1,8 @@
 using System;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using GroupHandle = TileDB.CSharp.Marshalling.SafeHandles.GroupHandle;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/sources/TileDB.CSharp/GroupMetadata.cs b/sources/TileDB.CSharp/GroupMetadata.cs
index a509e6a1..3c7a5253 100644
--- a/sources/TileDB.CSharp/GroupMetadata.cs
+++ b/sources/TileDB.CSharp/GroupMetadata.cs
@@ -2,7 +2,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 using TileDB.Interop;
@@ -30,7 +29,7 @@ public GroupMetadata(Group group)
         public void PutMetadata<T>(string key, T[] data) where T : struct
         {
             var tiledb_datatype = (tiledb_datatype_t)EnumUtil.TypeToDataType(typeof(T));
-            put_metadata(key, data, tiledb_datatype, (uint)data.Length);
+            put_metadata(key, data, tiledb_datatype);
         }
 
         /// <summary>
@@ -42,7 +41,7 @@ public void PutMetadata<T>(string key, T[] data) where T : struct
         public void PutMetadata<T>(string key, T v) where T : struct
         {
             T[] data = new T[1] { v };
-            PutMetadata<T>(key, data);
+            PutMetadata(key, data);
         }
 
         /// <summary>
@@ -52,10 +51,9 @@ public void PutMetadata<T>(string key, T v) where T : struct
         /// <param name="value"></param>
         public void PutMetadata(string key, string value)
         {
-            var tiledb_datatype = tiledb_datatype_t.TILEDB_STRING_ASCII;
-            var data = Encoding.ASCII.GetBytes(value);
-            var val_num = (uint)data.Length;
-            put_metadata<byte>(key, data, tiledb_datatype, val_num);
+            var tiledb_datatype = tiledb_datatype_t.TILEDB_STRING_UTF8;
+            var data = Encoding.UTF8.GetBytes(value);
+            put_metadata(key, data, tiledb_datatype);
         }
 
         /// <summary>
@@ -93,8 +91,8 @@ public T[] GetMetadata<T>(string key) where T : struct
         /// <returns></returns>
         public string GetMetadata(string key)
         {
-            var (_, byte_array, _, _) = get_metadata(key);
-            return MarshaledStringOut.GetString(byte_array);
+            var (_, byte_array, datatype, _) = get_metadata(key);
+            return MarshaledStringOut.GetString(byte_array, (DataType)datatype);
         }
 
         /// <summary>
@@ -266,7 +264,7 @@ public bool IsReadOnly
 
         public void Add(string key, byte[] value)
         {
-            put_metadata<byte>(key, value, tiledb_datatype_t.TILEDB_UINT8, (uint)value.Length);
+            put_metadata(key, value, tiledb_datatype_t.TILEDB_UINT8);
         }
 
         public void Add(KeyValuePair<string, byte[]> item)
@@ -330,7 +328,7 @@ IEnumerator IEnumerable.GetEnumerator()
         #endregion
 
         #region Private methods
-        private void put_metadata<T>(string key, T[] value, tiledb_datatype_t tiledb_datatype, uint value_num) where T : struct
+        private void put_metadata<T>(string key, T[] value, tiledb_datatype_t tiledb_datatype) where T : struct
         {
             ErrorHandling.ThrowIfManagedType<T>();
             if (string.IsNullOrEmpty(key) || value.Length == 0)
@@ -342,7 +340,7 @@ private void put_metadata<T>(string key, T[] value, tiledb_datatype_t tiledb_dat
             using var ctxHandle = ctx.Handle.Acquire();
             using var groupHandle = _group.Handle.Acquire();
             fixed (T* dataPtr = &value[0])
-                ctx.handle_error(Methods.tiledb_group_put_metadata(ctxHandle, groupHandle, ms_key, tiledb_datatype, value_num, dataPtr));
+                ctx.handle_error(Methods.tiledb_group_put_metadata(ctxHandle, groupHandle, ms_key, tiledb_datatype, (uint)value.Length, dataPtr));
         }
 
         private (string key, byte[] data, tiledb_datatype_t tiledb_datatype, uint value_num) get_metadata(string key)
diff --git a/sources/TileDB.CSharp/Interop/InteropAux.cs b/sources/TileDB.CSharp/Interop/InteropAux.cs
new file mode 100644
index 00000000..550fb248
--- /dev/null
+++ b/sources/TileDB.CSharp/Interop/InteropAux.cs
@@ -0,0 +1,13 @@
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
+namespace TileDB.Interop
+{
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    // placeholder struct to avoid errors loading generated code
+    public partial struct __sFILE
+    {
+    }
+}
\ No newline at end of file
diff --git a/sources/TileDB.CSharp/Interop/Methods.cs b/sources/TileDB.CSharp/Interop/Methods.cs
index 8802c9ff..ddb32754 100644
--- a/sources/TileDB.CSharp/Interop/Methods.cs
+++ b/sources/TileDB.CSharp/Interop/Methods.cs
@@ -17,6 +17,18 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("capi_status_t")]
         public static extern int tiledb_status_code([NativeTypeName("capi_return_t")] int x);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_datatype_to_str(tiledb_datatype_t datatype, [NativeTypeName("const char **")] sbyte** str);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_datatype_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_datatype_t* datatype);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("uint64_t")]
+        public static extern ulong tiledb_datatype_size(tiledb_datatype_t type);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_error_message(tiledb_error_t* err, [NativeTypeName("const char **")] sbyte** errmsg);
@@ -119,108 +131,256 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_datatype_to_str(tiledb_datatype_t datatype, [NativeTypeName("const char **")] sbyte** str);
+        public static extern int tiledb_filter_type_to_str(tiledb_filter_type_t filter_type, [NativeTypeName("const char **")] sbyte** str);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_datatype_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_datatype_t* datatype);
+        public static extern int tiledb_filter_type_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_filter_type_t* filter_type);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("uint64_t")]
-        public static extern ulong tiledb_datatype_size(tiledb_datatype_t type);
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_filter_option_to_str(tiledb_filter_option_t filter_option, [NativeTypeName("const char **")] sbyte** str);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_buffer_alloc(tiledb_ctx_t* ctx, tiledb_buffer_t** buffer);
+        public static extern int tiledb_filter_option_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_filter_option_t* filter_option);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void tiledb_buffer_free(tiledb_buffer_t** buffer);
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_filter_alloc(tiledb_ctx_t* ctx, tiledb_filter_type_t type, tiledb_filter_t** filter);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_filter_free(tiledb_filter_t** filter);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_buffer_set_type(tiledb_ctx_t* ctx, tiledb_buffer_t* buffer, tiledb_datatype_t datatype);
+        public static extern int tiledb_filter_get_type(tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_type_t* type);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_buffer_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_t *")] tiledb_buffer_t* buffer, tiledb_datatype_t* datatype);
+        public static extern int tiledb_filter_set_option(tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_option_t option, [NativeTypeName("const void *")] void* value);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_buffer_get_data(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_t *")] tiledb_buffer_t* buffer, void** data, [NativeTypeName("uint64_t *")] ulong* num_bytes);
+        public static extern int tiledb_filter_get_option(tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_option_t option, void* value);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_buffer_set_data(tiledb_ctx_t* ctx, tiledb_buffer_t* buffer, void* data, [NativeTypeName("uint64_t")] ulong size);
+        public static extern int tiledb_filter_list_alloc(tiledb_ctx_t* ctx, tiledb_filter_list_t** filter_list);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_filter_list_free(tiledb_filter_list_t** filter_list);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_data_order_to_str(tiledb_data_order_t data_order, [NativeTypeName("const char **")] sbyte** str);
+        public static extern int tiledb_filter_list_add_filter(tiledb_ctx_t* ctx, tiledb_filter_list_t* filter_list, tiledb_filter_t* filter);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_data_order_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_data_order_t* data_order);
+        public static extern int tiledb_filter_list_set_max_chunk_size(tiledb_ctx_t* ctx, tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t")] uint max_chunk_size);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_type_to_str(tiledb_filter_type_t filter_type, [NativeTypeName("const char **")] sbyte** str);
+        public static extern int tiledb_filter_list_get_nfilters(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_filter_list_t *")] tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t *")] uint* nfilters);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_type_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_filter_type_t* filter_type);
+        public static extern int tiledb_filter_list_get_filter_from_index(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_filter_list_t *")] tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t")] uint index, tiledb_filter_t** filter);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_option_to_str(tiledb_filter_option_t filter_option, [NativeTypeName("const char **")] sbyte** str);
+        public static extern int tiledb_filter_list_get_max_chunk_size(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_filter_list_t *")] tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t *")] uint* max_chunk_size);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_option_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_filter_option_t* filter_option);
+        public static extern int tiledb_string_view(tiledb_string_t* s, [NativeTypeName("const char **")] sbyte** data, [NativeTypeName("size_t *")] nuint* length);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_alloc(tiledb_ctx_t* ctx, tiledb_filter_type_t type, tiledb_filter_t** filter);
+        public static extern int tiledb_string_free(tiledb_string_t** s);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void tiledb_filter_free(tiledb_filter_t** filter);
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_alloc(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* name, tiledb_datatype_t type, tiledb_attribute_t** attr);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_attribute_free(tiledb_attribute_t** attr);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_set_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("uint8_t")] byte nullable);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_set_filter_list(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, tiledb_filter_list_t* filter_list);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_set_cell_val_num(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("uint32_t")] uint cell_val_num);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_name(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, [NativeTypeName("const char **")] sbyte** name);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, tiledb_datatype_t* type);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("uint8_t *")] byte* nullable);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_filter_list(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, tiledb_filter_list_t** filter_list);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_cell_val_num(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, [NativeTypeName("uint32_t *")] uint* cell_val_num);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_cell_size(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, [NativeTypeName("uint64_t *")] ulong* cell_size);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_set_fill_value(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void *")] void* value, [NativeTypeName("uint64_t")] ulong size);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_fill_value(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void **")] void** value, [NativeTypeName("uint64_t *")] ulong* size);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_set_fill_value_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void *")] void* value, [NativeTypeName("uint64_t")] ulong size, [NativeTypeName("uint8_t")] byte validity);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_attribute_get_fill_value_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void **")] void** value, [NativeTypeName("uint64_t *")] ulong* size, [NativeTypeName("uint8_t *")] byte* valid);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_get_type(tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_type_t* type);
+        public static extern int tiledb_buffer_alloc(tiledb_ctx_t* ctx, tiledb_buffer_t** buffer);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_buffer_free(tiledb_buffer_t** buffer);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_set_option(tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_option_t option, [NativeTypeName("const void *")] void* value);
+        public static extern int tiledb_buffer_set_type(tiledb_ctx_t* ctx, tiledb_buffer_t* buffer, tiledb_datatype_t datatype);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_get_option(tiledb_ctx_t* ctx, tiledb_filter_t* filter, tiledb_filter_option_t option, void* value);
+        public static extern int tiledb_buffer_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_t *")] tiledb_buffer_t* buffer, tiledb_datatype_t* datatype);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_list_alloc(tiledb_ctx_t* ctx, tiledb_filter_list_t** filter_list);
+        public static extern int tiledb_buffer_get_data(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_t *")] tiledb_buffer_t* buffer, void** data, [NativeTypeName("uint64_t *")] ulong* num_bytes);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void tiledb_filter_list_free(tiledb_filter_list_t** filter_list);
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_buffer_set_data(tiledb_ctx_t* ctx, tiledb_buffer_t* buffer, void* data, [NativeTypeName("uint64_t")] ulong size);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_list_add_filter(tiledb_ctx_t* ctx, tiledb_filter_list_t* filter_list, tiledb_filter_t* filter);
+        public static extern int tiledb_buffer_list_alloc(tiledb_ctx_t* ctx, tiledb_buffer_list_t** buffer_list);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_buffer_list_free(tiledb_buffer_list_t** buffer_list);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_list_set_max_chunk_size(tiledb_ctx_t* ctx, tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t")] uint max_chunk_size);
+        public static extern int tiledb_buffer_list_get_num_buffers(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_list_t *")] tiledb_buffer_list_t* buffer_list, [NativeTypeName("uint64_t *")] ulong* num_buffers);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_list_get_nfilters(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_filter_list_t *")] tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t *")] uint* nfilters);
+        public static extern int tiledb_buffer_list_get_buffer(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_list_t *")] tiledb_buffer_list_t* buffer_list, [NativeTypeName("uint64_t")] ulong buffer_idx, tiledb_buffer_t** buffer);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_list_get_filter_from_index(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_filter_list_t *")] tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t")] uint index, tiledb_filter_t** filter);
+        public static extern int tiledb_buffer_list_get_total_size(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_list_t *")] tiledb_buffer_list_t* buffer_list, [NativeTypeName("uint64_t *")] ulong* total_size);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_filter_list_get_max_chunk_size(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_filter_list_t *")] tiledb_filter_list_t* filter_list, [NativeTypeName("uint32_t *")] uint* max_chunk_size);
+        public static extern int tiledb_buffer_list_flatten(tiledb_ctx_t* ctx, tiledb_buffer_list_t* buffer_list, tiledb_buffer_t** buffer);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_data_order_to_str(tiledb_data_order_t data_order, [NativeTypeName("const char **")] sbyte** str);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_data_order_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_data_order_t* data_order);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_alloc(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* name, tiledb_datatype_t type, [NativeTypeName("const void *")] void* dim_domain, [NativeTypeName("const void *")] void* tile_extent, tiledb_dimension_t** dim);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_dimension_free(tiledb_dimension_t** dim);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_set_filter_list(tiledb_ctx_t* ctx, tiledb_dimension_t* dim, tiledb_filter_list_t* filter_list);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_set_cell_val_num(tiledb_ctx_t* ctx, tiledb_dimension_t* dim, [NativeTypeName("uint32_t")] uint cell_val_num);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_get_filter_list(tiledb_ctx_t* ctx, tiledb_dimension_t* dim, tiledb_filter_list_t** filter_list);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_get_cell_val_num(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("uint32_t *")] uint* cell_val_num);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_get_name(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("const char **")] sbyte** name);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, tiledb_datatype_t* type);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_get_domain(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("const void **")] void** domain);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_dimension_get_tile_extent(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("const void **")] void** tile_extent);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_alloc(tiledb_ctx_t* ctx, tiledb_domain_t** domain);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_domain_free(tiledb_domain_t** domain);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, tiledb_datatype_t* type);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_get_ndim(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("uint32_t *")] uint* ndim);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_add_dimension(tiledb_ctx_t* ctx, tiledb_domain_t* domain, tiledb_dimension_t* dim);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_get_dimension_from_index(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("uint32_t")] uint index, tiledb_dimension_t** dim);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_get_dimension_from_name(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("const char *")] sbyte* name, tiledb_dimension_t** dim);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_domain_has_dimension(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("const char *")] sbyte* name, [NativeTypeName("int32_t *")] int* has_dim);
 
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
@@ -251,14 +411,6 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_query_type_from_str([NativeTypeName("const char *")] sbyte* str, tiledb_query_type_t* query_type);
 
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_string_view(tiledb_string_t* s, [NativeTypeName("const char **")] sbyte** data, [NativeTypeName("size_t *")] nuint* length);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("capi_return_t")]
-        public static extern int tiledb_string_free(tiledb_string_t** s);
-
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_vfs_mode_to_str(tiledb_vfs_mode_t vfs_mode, [NativeTypeName("const char **")] sbyte** str);
@@ -432,158 +584,6 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         public static extern void tiledb_version([NativeTypeName("int32_t *")] int* major, [NativeTypeName("int32_t *")] int* minor, [NativeTypeName("int32_t *")] int* rev);
 
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_buffer_list_alloc(tiledb_ctx_t* ctx, tiledb_buffer_list_t** buffer_list);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void tiledb_buffer_list_free(tiledb_buffer_list_t** buffer_list);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_buffer_list_get_num_buffers(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_list_t *")] tiledb_buffer_list_t* buffer_list, [NativeTypeName("uint64_t *")] ulong* num_buffers);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_buffer_list_get_buffer(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_list_t *")] tiledb_buffer_list_t* buffer_list, [NativeTypeName("uint64_t")] ulong buffer_idx, tiledb_buffer_t** buffer);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_buffer_list_get_total_size(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_list_t *")] tiledb_buffer_list_t* buffer_list, [NativeTypeName("uint64_t *")] ulong* total_size);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_buffer_list_flatten(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_buffer_list_t *")] tiledb_buffer_list_t* buffer_list, tiledb_buffer_t** buffer);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_alloc(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* name, tiledb_datatype_t type, tiledb_attribute_t** attr);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void tiledb_attribute_free(tiledb_attribute_t** attr);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_set_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("uint8_t")] byte nullable);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_set_filter_list(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, tiledb_filter_list_t* filter_list);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_set_cell_val_num(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("uint32_t")] uint cell_val_num);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_name(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, [NativeTypeName("const char **")] sbyte** name);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, tiledb_datatype_t* type);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("uint8_t *")] byte* nullable);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_filter_list(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, tiledb_filter_list_t** filter_list);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_cell_val_num(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, [NativeTypeName("uint32_t *")] uint* cell_val_num);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_cell_size(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_attribute_t *")] tiledb_attribute_t* attr, [NativeTypeName("uint64_t *")] ulong* cell_size);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_set_fill_value(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void *")] void* value, [NativeTypeName("uint64_t")] ulong size);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_fill_value(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void **")] void** value, [NativeTypeName("uint64_t *")] ulong* size);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_set_fill_value_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void *")] void* value, [NativeTypeName("uint64_t")] ulong size, [NativeTypeName("uint8_t")] byte validity);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_attribute_get_fill_value_nullable(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const void **")] void** value, [NativeTypeName("uint64_t *")] ulong* size, [NativeTypeName("uint8_t *")] byte* valid);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_domain_alloc(tiledb_ctx_t* ctx, tiledb_domain_t** domain);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void tiledb_domain_free(tiledb_domain_t** domain);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_domain_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, tiledb_datatype_t* type);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_domain_get_ndim(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("uint32_t *")] uint* ndim);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_domain_add_dimension(tiledb_ctx_t* ctx, tiledb_domain_t* domain, tiledb_dimension_t* dim);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_domain_get_dimension_from_index(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("uint32_t")] uint index, tiledb_dimension_t** dim);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_domain_get_dimension_from_name(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("const char *")] sbyte* name, tiledb_dimension_t** dim);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_domain_has_dimension(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_domain_t *")] tiledb_domain_t* domain, [NativeTypeName("const char *")] sbyte* name, [NativeTypeName("int32_t *")] int* has_dim);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_alloc(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* name, tiledb_datatype_t type, [NativeTypeName("const void *")] void* dim_domain, [NativeTypeName("const void *")] void* tile_extent, tiledb_dimension_t** dim);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern void tiledb_dimension_free(tiledb_dimension_t** dim);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_set_filter_list(tiledb_ctx_t* ctx, tiledb_dimension_t* dim, tiledb_filter_list_t* filter_list);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_set_cell_val_num(tiledb_ctx_t* ctx, tiledb_dimension_t* dim, [NativeTypeName("uint32_t")] uint cell_val_num);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_get_filter_list(tiledb_ctx_t* ctx, tiledb_dimension_t* dim, tiledb_filter_list_t** filter_list);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_get_cell_val_num(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("uint32_t *")] uint* cell_val_num);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_get_name(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("const char **")] sbyte** name);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_get_type(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, tiledb_datatype_t* type);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_get_domain(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("const void **")] void** domain);
-
-        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        [return: NativeTypeName("int32_t")]
-        public static extern int tiledb_dimension_get_tile_extent(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_dimension_t *")] tiledb_dimension_t* dim, [NativeTypeName("const void **")] void** tile_extent);
-
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_schema_alloc(tiledb_ctx_t* ctx, tiledb_array_type_t array_type, tiledb_array_schema_t** array_schema);
@@ -900,6 +900,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_query_condition_combine(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_query_condition_t *")] tiledb_query_condition_t* left_cond, [NativeTypeName("const tiledb_query_condition_t *")] tiledb_query_condition_t* right_cond, tiledb_query_condition_combination_op_t combination_op, tiledb_query_condition_t** combined_cond);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_query_condition_negate(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_query_condition_t *")] tiledb_query_condition_t* cond, tiledb_query_condition_t** negated_cond);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_subarray_alloc(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_array_t *")] tiledb_array_t* array, tiledb_subarray_t** subarray);
@@ -1300,6 +1304,45 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_fragment_info_get_array_schema_name(tiledb_ctx_t* ctx, tiledb_fragment_info_t* fragment_info, [NativeTypeName("uint32_t")] uint fid, [NativeTypeName("const char **")] sbyte** schema_name);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_attribute_set_enumeration_name(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, [NativeTypeName("const char *")] sbyte* enumeration_name);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_attribute_get_enumeration_name(tiledb_ctx_t* ctx, tiledb_attribute_t* attr, tiledb_string_t** name);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_enumeration_alloc(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* name, tiledb_datatype_t type, [NativeTypeName("uint32_t")] uint cell_val_num, int ordered, [NativeTypeName("const void *")] void* data, [NativeTypeName("uint64_t")] ulong data_size, [NativeTypeName("const void *")] void* offsets, [NativeTypeName("uint64_t")] ulong offsets_size, tiledb_enumeration_t** enumeration);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void tiledb_enumeration_free(tiledb_enumeration_t** enumeration);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_enumeration_get_name(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, tiledb_string_t** name);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_enumeration_get_type(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, tiledb_datatype_t* type);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_enumeration_get_cell_val_num(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, [NativeTypeName("uint32_t *")] uint* cell_val_num);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_enumeration_get_ordered(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, int* ordered);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_enumeration_get_data(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, [NativeTypeName("const void **")] void** data, [NativeTypeName("uint64_t *")] ulong* data_size);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_enumeration_get_offsets(tiledb_ctx_t* ctx, tiledb_enumeration_t* enumeration, [NativeTypeName("const void **")] void** offsets, [NativeTypeName("uint64_t *")] ulong* offsets_size);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_group_alloc(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* group_uri, tiledb_group_t** group);
@@ -1399,6 +1442,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_group_vacuum_metadata(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* group_uri, tiledb_config_t* config);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_query_get_plan(tiledb_ctx_t* ctx, tiledb_query_t* query, tiledb_string_t** plan);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         public static extern void tiledb_dimension_label_free(tiledb_dimension_label_t** dim_label);
 
@@ -1450,6 +1497,14 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_array_schema_set_dimension_label_tile_extent(tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, [NativeTypeName("const char *")] sbyte* label_name, tiledb_datatype_t type, [NativeTypeName("const void *")] void* tile_extent);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_array_schema_get_dimension_label_num(tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, [NativeTypeName("uint64_t *")] ulong* dim_label_num);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_array_schema_get_dimension_label_from_index(tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, [NativeTypeName("uint64_t")] ulong dim_label_index, tiledb_dimension_label_t** dim_label);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_subarray_add_label_range(tiledb_ctx_t* ctx, tiledb_subarray_t* subarray, [NativeTypeName("const char *")] sbyte* label_name, [NativeTypeName("const void *")] void* start, [NativeTypeName("const void *")] void* end, [NativeTypeName("const void *")] void* stride);
@@ -1482,6 +1537,14 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("capi_return_t")]
         public static extern int tiledb_subarray_has_label_ranges(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_subarray_t *")] tiledb_subarray_t* subarray, [NativeTypeName("const uint32_t")] uint dim_idx, [NativeTypeName("int32_t *")] int* has_label_range);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_log_warn(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* message);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_as_built_dump(tiledb_string_t** @out);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_schema_evolution_alloc(tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t** array_schema_evolution);
@@ -1497,6 +1560,14 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_schema_evolution_drop_attribute(tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, [NativeTypeName("const char *")] sbyte* attribute_name);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_array_schema_evolution_add_enumeration(tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, tiledb_enumeration_t* enumeration);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_array_schema_evolution_drop_enumeration(tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, [NativeTypeName("const char *")] sbyte* enumeration_name);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_schema_evolution_set_timestamp_range(tiledb_ctx_t* ctx, tiledb_array_schema_evolution_t* array_schema_evolution, [NativeTypeName("uint64_t")] ulong lo, [NativeTypeName("uint64_t")] ulong hi);
@@ -1505,6 +1576,10 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_schema_timestamp_range(tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, [NativeTypeName("uint64_t *")] ulong* lo, [NativeTypeName("uint64_t *")] ulong* hi);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_array_schema_add_enumeration(tiledb_ctx_t* ctx, tiledb_array_schema_t* array_schema, tiledb_enumeration_t* enumeration);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_delete(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* uri);
@@ -1518,6 +1593,14 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_evolve(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* array_uri, tiledb_array_schema_evolution_t* array_schema_evolution);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_array_get_enumeration(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_array_t *")] tiledb_array_t* array, [NativeTypeName("const char *")] sbyte* name, tiledb_enumeration_t** enumeration);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_array_load_all_enumerations(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_array_t *")] tiledb_array_t* array);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_array_upgrade_version(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* array_uri, tiledb_config_t* config);
@@ -1539,6 +1622,14 @@ public static int tiledb_status([NativeTypeName("capi_return_t")] int x)
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_query_get_relevant_fragment_num(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_query_t *")] tiledb_query_t* query, [NativeTypeName("uint64_t *")] ulong* relevant_fragment_num);
 
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("capi_return_t")]
+        public static extern int tiledb_query_condition_alloc_set_membership(tiledb_ctx_t* ctx, [NativeTypeName("const char *")] sbyte* field_name, [NativeTypeName("const void *")] void* data, [NativeTypeName("uint64_t")] ulong data_size, [NativeTypeName("const void *")] void* offsets, [NativeTypeName("uint64_t")] ulong offests_size, tiledb_query_condition_op_t op, tiledb_query_condition_t** cond);
+
+        [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: NativeTypeName("int32_t")]
+        public static extern int tiledb_query_condition_set_use_enumeration(tiledb_ctx_t* ctx, [NativeTypeName("const tiledb_query_condition_t *")] tiledb_query_condition_t* cond, int use_enumeration);
+
         [DllImport("tiledb", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
         [return: NativeTypeName("int32_t")]
         public static extern int tiledb_query_get_status_details(tiledb_ctx_t* ctx, tiledb_query_t* query, tiledb_query_status_details_t* status_details);
diff --git a/sources/TileDB.CSharp/Interop/SpanExtensions.cs b/sources/TileDB.CSharp/Interop/SpanExtensions.cs
new file mode 100644
index 00000000..99a4ae4b
--- /dev/null
+++ b/sources/TileDB.CSharp/Interop/SpanExtensions.cs
@@ -0,0 +1,31 @@
+// Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
+//https://github.com/dotnet/ClangSharp/blob/67c1e5243b9d58f2b28f10e3f9a82f7537fd9d88/sources/ClangSharp.Interop/Internals/SpanExtensions.cs
+
+using System;
+using System.ComponentModel;
+using System.Text;
+using TileDB.CSharp;
+
+namespace TileDB.Interop
+{
+    [Obsolete(Obsoletions.TileDBInteropMessage, DiagnosticId = Obsoletions.TileDBInteropDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static unsafe class SpanExtensions
+    {
+        public static string AsString(this Span<byte> self) => AsString((ReadOnlySpan<byte>)self);
+
+        public static string AsString(this ReadOnlySpan<byte> self)
+        {
+            if (self.IsEmpty)
+            {
+                return string.Empty;
+            }
+
+            fixed (byte* pSelf = self)
+            {
+                return Encoding.ASCII.GetString(pSelf, self.Length);
+            }
+        }
+    }
+
+}//namespace
\ No newline at end of file
diff --git a/sources/TileDB.CSharp/Interop/TileDBSafeHandle.cs b/sources/TileDB.CSharp/Interop/TileDBSafeHandle.cs
new file mode 100644
index 00000000..864b4061
--- /dev/null
+++ b/sources/TileDB.CSharp/Interop/TileDBSafeHandle.cs
@@ -0,0 +1,663 @@
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using TileDB.CSharp;
+
+namespace TileDB.Interop
+{
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class ConfigHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+
+        public ConfigHandle() : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_config_t*[1];
+            var e = stackalloc tiledb_error_t*[1];
+            Methods.tiledb_config_alloc(h, e);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_config_t*)handle;
+            Methods.tiledb_config_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_config_t* h) { SetHandle((IntPtr)h); }
+        private protected ConfigHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(ConfigHandle h) => h.handle;
+        public static implicit operator tiledb_config_t*(ConfigHandle h) => (tiledb_config_t*)h.handle;
+        public static implicit operator ConfigHandle(tiledb_config_t* value) => new ConfigHandle((IntPtr)value);
+    }//public unsafe partial class ConfigHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class ConfigIteratorHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+
+        public ConfigIteratorHandle(ConfigHandle hconfig, string prefix) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_config_iter_t*[1];
+            var e = stackalloc tiledb_error_t*[1];
+            var ms_prefix = new MarshaledString(prefix);
+            Methods.tiledb_config_iter_alloc(hconfig, ms_prefix, h, e);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHTha andle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_config_iter_t*)handle;
+            Methods.tiledb_config_iter_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_config_iter_t* h) { SetHandle((IntPtr)h); }
+        private protected ConfigIteratorHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(ConfigIteratorHandle h) => h.handle;
+        public static implicit operator tiledb_config_iter_t*(ConfigIteratorHandle h) => (tiledb_config_iter_t*)h.handle;
+        public static implicit operator ConfigIteratorHandle(tiledb_config_iter_t* value) => new ConfigIteratorHandle((IntPtr)value);
+    }//public unsafe partial class ConfigHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class ContextHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public ContextHandle() : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_ctx_t*[1];
+            var hconfig = new ConfigHandle();
+            Methods.tiledb_ctx_alloc(hconfig, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        public ContextHandle(ConfigHandle hconfig) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_ctx_t*[1];
+            Methods.tiledb_ctx_alloc(hconfig, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_ctx_t*)handle;
+            Methods.tiledb_ctx_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_ctx_t* h) { SetHandle((IntPtr)h); }
+        private protected ContextHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(ContextHandle h) => h.handle;
+        public static implicit operator tiledb_ctx_t*(ContextHandle h) => (tiledb_ctx_t*)h.handle;
+        public static implicit operator ContextHandle(tiledb_ctx_t* value) => new ContextHandle((IntPtr)value);
+    }//public unsafe partial class ContextHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class FilterHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+
+        public FilterHandle(ContextHandle hcontext, tiledb_filter_type_t filterType) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_filter_t*[1];
+
+            Methods.tiledb_filter_alloc(hcontext, filterType, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_filter_t*)handle;
+            Methods.tiledb_filter_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_filter_t* h) { SetHandle((IntPtr)h); }
+        private protected FilterHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(FilterHandle h) => h.handle;
+        public static implicit operator tiledb_filter_t*(FilterHandle h) => (tiledb_filter_t*)h.handle;
+        public static implicit operator FilterHandle(tiledb_filter_t* value) => new FilterHandle((IntPtr)value);
+    }//public unsafe partial class FilterHandle
+
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class FilterListHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public FilterListHandle(ContextHandle hcontext) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_filter_list_t*[1];
+
+            Methods.tiledb_filter_list_alloc(hcontext, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_filter_list_t*)handle;
+            Methods.tiledb_filter_list_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_filter_list_t* h) { SetHandle((IntPtr)h); }
+        private protected FilterListHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(FilterListHandle h) => h.handle;
+        public static implicit operator tiledb_filter_list_t*(FilterListHandle h) => (tiledb_filter_list_t*)h.handle;
+        public static implicit operator FilterListHandle(tiledb_filter_list_t* value) => new FilterListHandle((IntPtr)value);
+    }//public unsafe partial class FilterListHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe partial class VFSHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+
+        public VFSHandle(ContextHandle hcontext, ConfigHandle hconfig) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_vfs_t*[1];
+
+            int status = TileDB.Interop.Methods.tiledb_vfs_alloc(hcontext, hconfig, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            tiledb_vfs_t* p = (tiledb_vfs_t*)handle;
+            TileDB.Interop.Methods.tiledb_vfs_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public UInt64 get() { return (UInt64)this.handle; }
+        private protected void SetHandle(tiledb_vfs_t* h) { SetHandle((IntPtr)h); }
+        private protected VFSHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => this.handle == IntPtr.Zero;
+        public static implicit operator IntPtr(VFSHandle h) => h.handle;
+        public static implicit operator tiledb_vfs_t*(VFSHandle h) => (tiledb_vfs_t*)h.handle;
+        public static implicit operator VFSHandle(tiledb_vfs_t* value) => new VFSHandle((IntPtr)value);
+    }//public unsafe partial class VFSHandle
+
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class AttributeHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public AttributeHandle(ContextHandle hcontext, string name, tiledb_datatype_t datatype) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_attribute_t*[1];
+
+            var ms_name = new MarshaledString(name);
+            Methods.tiledb_attribute_alloc(hcontext, ms_name, datatype, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_attribute_t*)handle;
+            Methods.tiledb_attribute_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_attribute_t* h) { SetHandle((IntPtr)h); }
+        private protected AttributeHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(AttributeHandle h) => h.handle;
+        public static implicit operator tiledb_attribute_t*(AttributeHandle h) => (tiledb_attribute_t*)h.handle;
+        public static implicit operator AttributeHandle(tiledb_attribute_t* value) => new AttributeHandle((IntPtr)value);
+    }//public unsafe partial class AttributeHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class DimensionHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+
+        public DimensionHandle(ContextHandle hcontext, string name, tiledb_datatype_t datatype, void* dimDomain, void* tileExtent) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_dimension_t*[1];
+
+            var ms_name = new MarshaledString(name);
+
+            Methods.tiledb_dimension_alloc(hcontext, ms_name, datatype, dimDomain, tileExtent, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_dimension_t*)handle;
+            Methods.tiledb_dimension_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_dimension_t* h) { SetHandle((IntPtr)h); }
+        private protected DimensionHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(DimensionHandle h) => h.handle;
+        public static implicit operator tiledb_dimension_t*(DimensionHandle h) => (tiledb_dimension_t*)h.handle;
+        public static implicit operator DimensionHandle(tiledb_dimension_t* value) => new DimensionHandle((IntPtr)value);
+    }//public unsafe partial class DimensionHandle
+
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class DomainHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+
+        public DomainHandle(ContextHandle hcontext) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_domain_t*[1];
+
+            Methods.tiledb_domain_alloc(hcontext, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_domain_t*)handle;
+            Methods.tiledb_domain_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_domain_t* h) { SetHandle((IntPtr)h); }
+        private protected DomainHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(DomainHandle h) => h.handle;
+        public static implicit operator tiledb_domain_t*(DomainHandle h) => (tiledb_domain_t*)h.handle;
+        public static implicit operator DomainHandle(tiledb_domain_t* value) => new DomainHandle((IntPtr)value);
+    }//public unsafe partial class DomainHandle
+
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class ArraySchemaHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public ArraySchemaHandle(ContextHandle contextHandle, tiledb_array_type_t arrayType) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_array_schema_t*[1];
+
+            Methods.tiledb_array_schema_alloc(contextHandle, arrayType, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_array_schema_t*)handle;
+            Methods.tiledb_array_schema_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_array_schema_t* h) { SetHandle((IntPtr)h); }
+        private protected ArraySchemaHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(ArraySchemaHandle h) => h.handle;
+        public static implicit operator tiledb_array_schema_t*(ArraySchemaHandle h) => (tiledb_array_schema_t*)h.handle;
+        public static implicit operator ArraySchemaHandle(tiledb_array_schema_t* value) => new ArraySchemaHandle((IntPtr)value);
+    }//public unsafe partial class ArraySchemaHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class ArrayHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public ArrayHandle(ContextHandle contextHandle, sbyte* uri) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_array_t*[1];
+
+            Methods.tiledb_array_alloc(contextHandle, uri, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_array_t*)handle;
+            Methods.tiledb_array_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_array_t* h) { SetHandle((IntPtr)h); }
+        private protected ArrayHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(ArrayHandle h) => h.handle;
+        public static implicit operator tiledb_array_t*(ArrayHandle h) => (tiledb_array_t*)h.handle;
+        public static implicit operator ArrayHandle(tiledb_array_t* value) => new ArrayHandle((IntPtr)value);
+    }//public unsafe partial class ArrayHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class ArraySchemaEvolutionHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public ArraySchemaEvolutionHandle(ContextHandle contextHandle) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_array_schema_evolution_t*[1];
+            Methods.tiledb_array_schema_evolution_alloc(contextHandle, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate ArraySchemaEvolutionHandle!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        protected override bool ReleaseHandle()
+        {
+            var p = (tiledb_array_schema_evolution_t*)handle;
+            Methods.tiledb_array_schema_evolution_free(&p);
+            SetHandle(IntPtr.Zero);
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() => (ulong)handle;
+        private protected void SetHandle(tiledb_array_schema_evolution_t* h) => SetHandle((IntPtr)h);
+        private protected ArraySchemaEvolutionHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(ArraySchemaEvolutionHandle h) => h.handle;
+        public static implicit operator tiledb_array_schema_evolution_t*(ArraySchemaEvolutionHandle h) =>
+            (tiledb_array_schema_evolution_t*)h.handle;
+        public static implicit operator ArraySchemaEvolutionHandle(tiledb_array_schema_evolution_t* value) =>
+            new ArraySchemaEvolutionHandle((IntPtr)value);
+    }//public unsafe class ArraySchemaEvolutionHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class QueryHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public QueryHandle(ContextHandle contextHandle, ArrayHandle arrayHandle, tiledb_query_type_t queryType) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_query_t*[1];
+
+            Methods.tiledb_query_alloc(contextHandle, arrayHandle, queryType, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_query_t*)handle;
+            Methods.tiledb_query_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_query_t* h) { SetHandle((IntPtr)h); }
+        private protected QueryHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(QueryHandle h) => h.handle;
+        public static implicit operator tiledb_query_t*(QueryHandle h) => (tiledb_query_t*)h.handle;
+        public static implicit operator QueryHandle(tiledb_query_t* value) => new QueryHandle((IntPtr)value);
+    }//public unsafe partial class QueryHandle
+
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class QueryConditionHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public QueryConditionHandle(ContextHandle contextHandle) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_query_condition_t*[1];
+
+            Methods.tiledb_query_condition_alloc(contextHandle, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_query_condition_t*)handle;
+            Methods.tiledb_query_condition_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_query_condition_t* h) { SetHandle((IntPtr)h); }
+        private protected QueryConditionHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(QueryConditionHandle h) => h.handle;
+        public static implicit operator tiledb_query_condition_t*(QueryConditionHandle h) => (tiledb_query_condition_t*)h.handle;
+        public static implicit operator QueryConditionHandle(tiledb_query_condition_t* value) => new QueryConditionHandle((IntPtr)value);
+    }//public unsafe partial class QueryConditionHandle
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class GroupHandle : SafeHandle
+    {
+        // Constructor for a Handle
+        //   - calls native allocator
+        //   - exception on failure
+        public GroupHandle(ContextHandle contextHandle, sbyte* uri) : base(IntPtr.Zero, ownsHandle: true)
+        {
+            var h = stackalloc tiledb_group_t*[1];
+
+            Methods.tiledb_group_alloc(contextHandle, uri, h);
+
+            if (h[0] == (void*)0)
+            {
+                throw new Exception("Failed to allocate!");
+            }
+            SetHandle(h[0]);
+        }
+
+        // Deallocator: call native free with CER guarantees from SafeHandle
+        override protected bool ReleaseHandle()
+        {
+            // Free the native object
+            var p = (tiledb_group_t*)handle;
+            Methods.tiledb_group_free(&p);
+            // Invalidate the contained pointer
+            SetHandle(IntPtr.Zero);
+
+            return true;
+        }
+
+        // Conversions, getters, operators
+        public ulong Get() { return (ulong)handle; }
+        private protected void SetHandle(tiledb_group_t* h) { SetHandle((IntPtr)h); }
+        private protected GroupHandle(IntPtr value) : base(value, ownsHandle: false) { }
+        public override bool IsInvalid => handle == IntPtr.Zero;
+        public static implicit operator IntPtr(GroupHandle h) => h.handle;
+        public static implicit operator tiledb_group_t*(GroupHandle h) => (tiledb_group_t*)h.handle;
+        public static implicit operator GroupHandle(tiledb_group_t* value) => new GroupHandle((IntPtr)value);
+    }//public unsafe partial class GroupHandle
+
+}//namespace
\ No newline at end of file
diff --git a/sources/TileDB.CSharp/Interop/tiledb_array_schema_evolution_t.cs b/sources/TileDB.CSharp/Interop/tiledb_array_schema_evolution_t.cs
index 5963a931..62f30fd0 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_array_schema_evolution_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_array_schema_evolution_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_array_schema_evolution_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_array_schema_evolution_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_array_schema_t.cs b/sources/TileDB.CSharp/Interop/tiledb_array_schema_t.cs
index 0ed17363..d6e93260 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_array_schema_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_array_schema_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_array_schema_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_array_schema_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_array_t.cs b/sources/TileDB.CSharp/Interop/tiledb_array_t.cs
index f4ac4bd3..bae73dd0 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_array_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_array_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_array_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_array_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_array_type_t.cs b/sources/TileDB.CSharp/Interop/tiledb_array_type_t.cs
index 76531f36..68bb1502 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_array_type_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_array_type_t.cs
@@ -2,7 +2,7 @@
 
 namespace TileDB.Interop
 {
-    internal enum tiledb_array_type_t
+    public enum tiledb_array_type_t
     {
         TILEDB_DENSE = 0,
         TILEDB_SPARSE = 1,
diff --git a/sources/TileDB.CSharp/Interop/tiledb_attribute_t.cs b/sources/TileDB.CSharp/Interop/tiledb_attribute_t.cs
index 8fbcb379..1f2fd94a 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_attribute_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_attribute_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_attribute_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_attribute_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_config_iter_t.cs b/sources/TileDB.CSharp/Interop/tiledb_config_iter_t.cs
index 82bae077..b3d56456 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_config_iter_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_config_iter_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_config_iter_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_config_iter_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_config_t.cs b/sources/TileDB.CSharp/Interop/tiledb_config_t.cs
index 2aed2874..96028ce4 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_config_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_config_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_config_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_config_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_ctx_t.cs b/sources/TileDB.CSharp/Interop/tiledb_ctx_t.cs
index 2f85340b..fa79c90d 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_ctx_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_ctx_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_ctx_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_ctx_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_datatype_t.cs b/sources/TileDB.CSharp/Interop/tiledb_datatype_t.cs
index 2d699b8f..b9d04e93 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_datatype_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_datatype_t.cs
@@ -2,7 +2,7 @@
 
 namespace TileDB.Interop
 {
-    internal enum tiledb_datatype_t
+    public enum tiledb_datatype_t
     {
         TILEDB_INT32 = 0,
         TILEDB_INT64 = 1,
diff --git a/sources/TileDB.CSharp/Interop/tiledb_dimension_t.cs b/sources/TileDB.CSharp/Interop/tiledb_dimension_t.cs
index 9bd83817..2e6b4810 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_dimension_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_dimension_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_dimension_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_dimension_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_domain_t.cs b/sources/TileDB.CSharp/Interop/tiledb_domain_t.cs
index 7f452823..37300e31 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_domain_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_domain_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_domain_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_domain_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_enumeration_t.cs b/sources/TileDB.CSharp/Interop/tiledb_enumeration_t.cs
new file mode 100644
index 00000000..a52dc744
--- /dev/null
+++ b/sources/TileDB.CSharp/Interop/tiledb_enumeration_t.cs
@@ -0,0 +1,8 @@
+// <auto-generated/>
+
+namespace TileDB.Interop
+{
+    internal partial struct tiledb_enumeration_t
+    {
+    }
+}
diff --git a/sources/TileDB.CSharp/Interop/tiledb_filter_list_t.cs b/sources/TileDB.CSharp/Interop/tiledb_filter_list_t.cs
index 863bd8cf..2f6f888f 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_filter_list_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_filter_list_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_filter_list_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_filter_list_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_filter_option_t.cs b/sources/TileDB.CSharp/Interop/tiledb_filter_option_t.cs
index 2fbf8700..7ce3b008 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_filter_option_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_filter_option_t.cs
@@ -13,5 +13,6 @@ internal enum tiledb_filter_option_t
         TILEDB_WEBP_QUALITY = 6,
         TILEDB_WEBP_INPUT_FORMAT = 7,
         TILEDB_WEBP_LOSSLESS = 8,
+        TILEDB_COMPRESSION_REINTERPRET_DATATYPE = 9,
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_filter_t.cs b/sources/TileDB.CSharp/Interop/tiledb_filter_t.cs
index b0e96e82..f7d7ff77 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_filter_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_filter_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_filter_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_filter_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_filter_type_t.cs b/sources/TileDB.CSharp/Interop/tiledb_filter_type_t.cs
index 847df364..749a8ad0 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_filter_type_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_filter_type_t.cs
@@ -2,7 +2,7 @@
 
 namespace TileDB.Interop
 {
-    internal enum tiledb_filter_type_t
+    public enum tiledb_filter_type_t
     {
         TILEDB_FILTER_NONE = 0,
         TILEDB_FILTER_GZIP = 1,
@@ -22,5 +22,6 @@ internal enum tiledb_filter_type_t
         TILEDB_FILTER_XOR = 16,
         TILEDB_FILTER_DEPRECATED = 17,
         TILEDB_FILTER_WEBP = 18,
+        TILEDB_FILTER_DELTA = 19,
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_group_t.cs b/sources/TileDB.CSharp/Interop/tiledb_group_t.cs
index e0f44057..70553720 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_group_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_group_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_group_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_group_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_query_condition_op_t.cs b/sources/TileDB.CSharp/Interop/tiledb_query_condition_op_t.cs
index 487979c5..5d09b670 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_query_condition_op_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_query_condition_op_t.cs
@@ -10,5 +10,7 @@ internal enum tiledb_query_condition_op_t
         TILEDB_GE = 3,
         TILEDB_EQ = 4,
         TILEDB_NE = 5,
+        TILEDB_IN = 6,
+        TILEDB_NOT_IN = 7,
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_query_condition_t.cs b/sources/TileDB.CSharp/Interop/tiledb_query_condition_t.cs
index 75b882fb..80146f30 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_query_condition_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_query_condition_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_query_condition_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_query_condition_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_query_status_t.cs b/sources/TileDB.CSharp/Interop/tiledb_query_status_t.cs
index 630e4f34..2c0716d6 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_query_status_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_query_status_t.cs
@@ -9,5 +9,6 @@ internal enum tiledb_query_status_t
         TILEDB_INPROGRESS = 2,
         TILEDB_INCOMPLETE = 3,
         TILEDB_UNINITIALIZED = 4,
+        TILEDB_INITIALIZED = 5,
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_query_t.cs b/sources/TileDB.CSharp/Interop/tiledb_query_t.cs
index f789f361..d4394468 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_query_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_query_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_query_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_query_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Interop/tiledb_query_type_t.cs b/sources/TileDB.CSharp/Interop/tiledb_query_type_t.cs
index 21fa4db6..c917e8a7 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_query_type_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_query_type_t.cs
@@ -2,7 +2,7 @@
 
 namespace TileDB.Interop
 {
-    internal enum tiledb_query_type_t
+    public enum tiledb_query_type_t
     {
         TILEDB_READ = 0,
         TILEDB_WRITE = 1,
diff --git a/sources/TileDB.CSharp/Interop/tiledb_vfs_t.cs b/sources/TileDB.CSharp/Interop/tiledb_vfs_t.cs
index 49275ccf..af349707 100644
--- a/sources/TileDB.CSharp/Interop/tiledb_vfs_t.cs
+++ b/sources/TileDB.CSharp/Interop/tiledb_vfs_t.cs
@@ -1,8 +1,14 @@
 // <auto-generated/>
 
+using System.ComponentModel;
+using System;
+using TileDB.CSharp;
+
 namespace TileDB.Interop
 {
-    internal partial struct tiledb_vfs_t
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public partial struct tiledb_vfs_t
     {
     }
 }
diff --git a/sources/TileDB.CSharp/Marshalling/MarshaledString.cs b/sources/TileDB.CSharp/Marshalling/MarshaledString.cs
index 4bebefa4..428d437e 100644
--- a/sources/TileDB.CSharp/Marshalling/MarshaledString.cs
+++ b/sources/TileDB.CSharp/Marshalling/MarshaledString.cs
@@ -1,13 +1,17 @@
 // Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
 
 using System;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Text;
+using TileDB.CSharp;
 
 namespace TileDB.Interop
 {
-    internal unsafe struct MarshaledString : IDisposable
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe struct MarshaledString : IDisposable
     {
         public MarshaledString(string input)
         {
@@ -15,7 +19,7 @@ public MarshaledString(string input)
             Value = (sbyte*)ptr;
         }
 
-        public static (IntPtr Pointer, int Length) AllocNullTerminated(string str)
+        internal static (IntPtr Pointer, int Length) AllocNullTerminated(string str)
         {
             if (str is null)
             {
@@ -30,7 +34,9 @@ public static (IntPtr Pointer, int Length) AllocNullTerminated(string str)
             return ((IntPtr)ptr, length);
         }
 
-        public static void FreeNullTerminated(IntPtr ptr) => Marshal.FreeHGlobal(ptr);
+        internal static void FreeNullTerminated(IntPtr ptr) => Marshal.FreeHGlobal(ptr);
+
+        public ReadOnlySpan<byte> AsSpan() => new ReadOnlySpan<byte>(Value, Length);
 
         public int Length { get; private set; }
 
diff --git a/sources/TileDB.CSharp/Marshalling/MarshaledStringOut.cs b/sources/TileDB.CSharp/Marshalling/MarshaledStringOut.cs
index f6437494..4850c2b7 100644
--- a/sources/TileDB.CSharp/Marshalling/MarshaledStringOut.cs
+++ b/sources/TileDB.CSharp/Marshalling/MarshaledStringOut.cs
@@ -1,18 +1,36 @@
 using System;
+using System.ComponentModel;
 using System.Text;
 using TileDB.CSharp;
 
 namespace TileDB.Interop
 {
-    internal static class MarshaledStringOut
+    [Obsolete(Obsoletions.TileDBInteropMessage, DiagnosticId = Obsoletions.TileDBInteropDiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class LibC
     {
+        // public struct handle_t {}
+        // [DllImport(LibDllImport.LibCPath)]
+        // public static extern void free(void* p);
+    }
+
+    [Obsolete(Obsoletions.TileDBInterop2Message, DiagnosticId = Obsoletions.TileDBInterop2DiagId, UrlFormat = Obsoletions.SharedUrlFormat)]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public unsafe class MarshaledStringOut
+    {
+        public sbyte* Value;
+        public MarshaledStringOut()
+        {
+            Value = null;
+        }
+
         /// <summary>
         /// Encodes a read-only span of bytes into a string, using the default encoding.
         /// </summary>
-        public static string GetString(ReadOnlySpan<byte> span) =>
+        internal static string GetString(ReadOnlySpan<byte> span) =>
             Encoding.ASCII.GetString(span);
 
-        public static string GetString(ReadOnlySpan<byte> span, DataType dataType) =>
+        internal static string GetString(ReadOnlySpan<byte> span, DataType dataType) =>
             dataType switch
             {
                 DataType.StringAscii => Encoding.ASCII.GetString(span),
@@ -25,7 +43,7 @@ public static string GetString(ReadOnlySpan<byte> span, DataType dataType) =>
         /// <summary>
         /// Encodes a null-terminated pointer of bytes into a string, using the default encoding.
         /// </summary>
-        public static unsafe string GetStringFromNullTerminated(sbyte* ptr)
+        internal static unsafe string GetStringFromNullTerminated(sbyte* ptr)
         {
             if (ptr == null)
             {
@@ -36,5 +54,7 @@ public static unsafe string GetStringFromNullTerminated(sbyte* ptr)
             span = span[0..span.IndexOf((byte)0)];
             return GetString(span);
         }
+
+        public static implicit operator string(MarshaledStringOut s) => GetStringFromNullTerminated(s.Value);
     }
 }
diff --git a/sources/TileDB.CSharp/Marshalling/SafeHandles/ContextHandle.cs b/sources/TileDB.CSharp/Marshalling/SafeHandles/ContextHandle.cs
index 421ee880..522eaa08 100644
--- a/sources/TileDB.CSharp/Marshalling/SafeHandles/ContextHandle.cs
+++ b/sources/TileDB.CSharp/Marshalling/SafeHandles/ContextHandle.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Runtime.InteropServices;
-using TileDB.CSharp;
 using TileDB.Interop;
 
 namespace TileDB.CSharp.Marshalling.SafeHandles
@@ -11,15 +10,14 @@ public ContextHandle() : base(IntPtr.Zero, true) { }
 
         public ContextHandle(IntPtr handle, bool ownsHandle) : base(IntPtr.Zero, ownsHandle) { SetHandle(handle); }
 
-        public static ContextHandle Create()
+        public static ContextHandle Create(ConfigHandle? configHandle = null)
         {
             var handle = new ContextHandle();
             var successful = false;
             tiledb_ctx_t* context = null;
             try
             {
-                using var configHandle = ConfigHandle.Create();
-                using var configHandleHolder = configHandle.Acquire();
+                using var configHandleHolder = configHandle?.Acquire() ?? default;
                 ErrorHandling.ThrowOnError(Methods.tiledb_ctx_alloc(configHandleHolder, &context));
                 successful = true;
             }
@@ -38,32 +36,6 @@ public static ContextHandle Create()
             return handle;
         }
 
-        public static ContextHandle Create(ConfigHandle configHandle)
-        {
-            var handle = new ContextHandle();
-            var successful = false;
-            tiledb_ctx_t* context = null;
-            try
-            {
-                using var configHandleHolder = configHandle.Acquire();
-                Methods.tiledb_ctx_alloc(configHandleHolder, &context);
-                successful = true;
-            }
-            finally
-            {
-                if (successful)
-                {
-                    handle.InitHandle(context);
-                }
-                else
-                {
-                    handle.SetHandleAsInvalid();
-                }
-            }
-
-            return handle;
-        }
-
         protected override bool ReleaseHandle()
         {
             fixed (IntPtr* p = &handle)
diff --git a/sources/TileDB.CSharp/Obsoletions.cs b/sources/TileDB.CSharp/Obsoletions.cs
index 400419ba..33850a81 100644
--- a/sources/TileDB.CSharp/Obsoletions.cs
+++ b/sources/TileDB.CSharp/Obsoletions.cs
@@ -38,5 +38,8 @@ internal static class Obsoletions
 
         public const string QuerySubarrayMessage = "Subarray-related methods of the Query class are obsolete and will become unavailable in a future version.";
         public const string QuerySubarrayDiagId = "TILEDB0011";
+
+        public const string TileDBInterop2Message = "Members of the TileDB.Interop namespace should not be used by user code and will become internal in a future version.";
+        public const string TileDBInterop2DiagId = "TILEDB0012";
     }
 }
diff --git a/sources/TileDB.CSharp/Query.cs b/sources/TileDB.CSharp/Query.cs
index 79eba5f6..8b703800 100644
--- a/sources/TileDB.CSharp/Query.cs
+++ b/sources/TileDB.CSharp/Query.cs
@@ -7,6 +7,8 @@
 using System.Text;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using QueryHandle = TileDB.CSharp.Marshalling.SafeHandles.QueryHandle;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
 
 namespace TileDB.CSharp
 {
@@ -91,6 +93,11 @@ public sealed unsafe class Query : IDisposable
         /// <param name="ctx">The context associated with this query.</param>
         /// <param name="array">The array on which the query will operate.</param>
         /// <param name="queryType">The query's type.</param>
+        /// <remarks>
+        /// This overload is not recommended for use in new code.
+        /// You should use <see cref="Query(CSharp.Array, CSharp.QueryType)"/> instead.
+        /// </remarks>
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Query(Context ctx, Array array, QueryType queryType)
         {
             _ctx = ctx;
@@ -103,12 +110,25 @@ public Query(Context ctx, Array array, QueryType queryType)
         /// </summary>
         /// <param name="ctx">The context associated with this query.</param>
         /// <param name="array">The array on which the query will operate. Its <see cref="Array.QueryType"/> will be used for the query.</param>
-        public Query(Context ctx, Array array)
-        {
-            _ctx = ctx;
-            _array = array;
-            _handle = QueryHandle.Create(ctx, array.Handle, (tiledb_query_type_t)array.QueryType());
-        }
+        /// <remarks>
+        /// This overload is not recommended for use in new code.
+        /// You should use <see cref="Query(CSharp.Array)"/> instead.
+        /// </remarks>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public Query(Context ctx, Array array) : this(ctx, array, array.QueryType()) { }
+
+        /// <summary>
+        /// Creates a <see cref="Query"/>.
+        /// </summary>
+        /// <param name="array">The array on which the query will operate.</param>
+        /// <param name="queryType">The query's type.</param>
+        public Query(Array array, QueryType queryType) : this(array.Context(), array, queryType) { }
+
+        /// <summary>
+        /// Creates a <see cref="Query"/> with an implicit <see cref="CSharp.QueryType"/>.
+        /// </summary>
+        /// <param name="array">The array on which the query will operate. Its <see cref="Array.QueryType"/> will be used for the query.</param>
+        public Query(Array array) : this(array.Context(), array) { }
 
         /// <summary>
         /// Disposes this <see cref="Query"/>.
diff --git a/sources/TileDB.CSharp/QueryCondition.cs b/sources/TileDB.CSharp/QueryCondition.cs
index 8834f3ff..f12cc4c0 100644
--- a/sources/TileDB.CSharp/QueryCondition.cs
+++ b/sources/TileDB.CSharp/QueryCondition.cs
@@ -1,6 +1,7 @@
 using System;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using QueryConditionHandle = TileDB.CSharp.Marshalling.SafeHandles.QueryConditionHandle;
 
 namespace TileDB.CSharp
 {
@@ -202,7 +203,35 @@ public static QueryCondition CreateIsNotNull(Context ctx, string attribute_name)
         /// <param name="condition">The query condition to negate.</param>
         /// <returns>A query condition that will be satisfied if
         /// <paramref name="condition"/> is not satisfied.</returns>
-        public static QueryCondition operator !(QueryCondition condition) =>
-            Combine(condition, null, QueryConditionCombinationOperatorType.Not);
+        public static QueryCondition operator !(QueryCondition condition)
+        {
+            var ctx = condition._ctx;
+
+            var handle = new QueryConditionHandle();
+            var successful = false;
+            tiledb_query_condition_t* condition_p = null;
+            try
+            {
+                using (var ctxHandle = ctx.Handle.Acquire())
+                using (var conditionHandle = condition.Handle.Acquire())
+                {
+                    ctx.handle_error(Methods.tiledb_query_condition_negate(ctxHandle, conditionHandle, &condition_p));
+                }
+                successful = true;
+            }
+            finally
+            {
+                if (successful)
+                {
+                    handle.InitHandle(condition_p);
+                }
+                else
+                {
+                    handle.SetHandleAsInvalid();
+                }
+            }
+
+            return new QueryCondition(ctx, handle);
+        }
     }
 }
diff --git a/sources/TileDB.CSharp/TileDB.CSharp.csproj b/sources/TileDB.CSharp/TileDB.CSharp.csproj
index bf31dffe..01330c29 100644
--- a/sources/TileDB.CSharp/TileDB.CSharp.csproj
+++ b/sources/TileDB.CSharp/TileDB.CSharp.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <Import Project="../NuGet.props" />
   <PropertyGroup>
     <TargetFramework>net5.0</TargetFramework>
@@ -6,10 +6,13 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
     <RootNamespace>TileDB.CSharp</RootNamespace>
-    <Version>5.4.0</Version>
+    <Version>5.7.0</Version>
     <Description>C# wrapper of the TileDB Embedded universal data engine.</Description>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <EnablePackageValidation>true</EnablePackageValidation>
+    <PackageValidationBaselineVersion>5.6.0</PackageValidationBaselineVersion>
+    <NoWarn>$(NoWarn);TILEDB0012</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/sources/TileDB.CSharp/VFS.cs b/sources/TileDB.CSharp/VFS.cs
index 66054314..8782a49e 100644
--- a/sources/TileDB.CSharp/VFS.cs
+++ b/sources/TileDB.CSharp/VFS.cs
@@ -6,6 +6,8 @@
 using System.Runtime.InteropServices;
 using TileDB.CSharp.Marshalling.SafeHandles;
 using TileDB.Interop;
+using ConfigHandle = TileDB.CSharp.Marshalling.SafeHandles.ConfigHandle;
+using VFSHandle = TileDB.CSharp.Marshalling.SafeHandles.VFSHandle;
 
 namespace TileDB.CSharp
 {
diff --git a/tests/TileDB.CSharp.Test/ArrayMetadataTest.cs b/tests/TileDB.CSharp.Test/ArrayMetadataTest.cs
index 87612d82..d49c19a0 100644
--- a/tests/TileDB.CSharp.Test/ArrayMetadataTest.cs
+++ b/tests/TileDB.CSharp.Test/ArrayMetadataTest.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -74,7 +74,7 @@ private void writeArrayMetadata(string tmpArrayPath)
 
             array.PutMetadata<float>("key4", new float[] { 25.1f, 26.2f, 27.3f, 28.4f });
 
-            array.PutMetadata("key5", "This is TileDB array metadata");
+            array.PutMetadata("key5", "This is TileDB array metadata, that supports Unicode characters! 🥳");
 
             array.Close();
         }
@@ -101,7 +101,7 @@ private void readArrayMetadata(string tmpArrayPath)
             CollectionAssert.AreEqual(new float[]{ 25.1f, 26.2f, 27.3f, 28.4f }, v4);
 
             var s = array.GetMetadata("key5");
-            Assert.AreEqual("This is TileDB array metadata", s);
+            Assert.AreEqual("This is TileDB array metadata, that supports Unicode characters! 🥳", s);
 
             var num = array.MetadataNum();
             Assert.AreEqual((ulong)5,  num);
diff --git a/tests/TileDB.CSharp.Test/ArrayTest.cs b/tests/TileDB.CSharp.Test/ArrayTest.cs
index e8a7e873..6180e829 100644
--- a/tests/TileDB.CSharp.Test/ArrayTest.cs
+++ b/tests/TileDB.CSharp.Test/ArrayTest.cs
@@ -147,7 +147,7 @@ public void TestConsolidateFragments()
                 using var array = new Array(context, uri);
                 array.Open(QueryType.Write);
 
-                using var query = new Query(context, array, QueryType.Write);
+                using var query = new Query(array, QueryType.Write);
                 query.SetDataBuffer("a1", a1Data);
                 query.SetDataBuffer("a2", a2Data);
                 query.SetOffsetsBuffer("a2", a2Offsets);
diff --git a/tests/TileDB.CSharp.Test/AttributeTest.cs b/tests/TileDB.CSharp.Test/AttributeTest.cs
index 970bea68..a2c8466b 100644
--- a/tests/TileDB.CSharp.Test/AttributeTest.cs
+++ b/tests/TileDB.CSharp.Test/AttributeTest.cs
@@ -211,7 +211,7 @@ private void writeVarLengthAttributeArray()
             ulong[] a2_el_off = new ulong[16] { 0, 2, 4, 5, 6, 7, 9, 11, 14, 16, 17, 18, 20, 21, 24, 25};
             ulong[] a2_off = CoreUtil.ElementOffsetsToByteOffsets(a2_el_off, DataType.Int32);
 
-            var query_write = new Query(context, array_write);
+            var query_write = new Query(array_write);
             query_write.SetLayout(LayoutType.RowMajor);
             // using var subarray = new Subarray(array_write);
             // subarray.SetSubarray(new int[] { 1, 4, 4, 4 });
@@ -239,7 +239,7 @@ private void readVarLengthAttributeArray()
             Assert.IsNotNull(array_read);
             array_read.Open(QueryType.Read);
 
-            var query_read = new Query(context, array_read);
+            var query_read = new Query(array_read);
 
             // Slice only rows 1,2 and cols 2,3,4
             using var subarray = new Subarray(array_read);
diff --git a/tests/TileDB.CSharp.Test/CoreUtilTest.cs b/tests/TileDB.CSharp.Test/CoreUtilTest.cs
new file mode 100644
index 00000000..a18e81f9
--- /dev/null
+++ b/tests/TileDB.CSharp.Test/CoreUtilTest.cs
@@ -0,0 +1,16 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace TileDB.CSharp.Test
+{
+    [TestClass]
+    public class CoreUtilTest
+    {
+        [TestMethod]
+        public void BuildConfigurationNonEmpty()
+        {
+            var buildConfiguration = CoreUtil.GetBuildConfiguration();
+
+            Assert.IsFalse(string.IsNullOrWhiteSpace(buildConfiguration));
+        }
+    }
+}
diff --git a/tests/TileDB.CSharp.Test/DeletesTest.cs b/tests/TileDB.CSharp.Test/DeletesTest.cs
index 803863bb..94628a1f 100644
--- a/tests/TileDB.CSharp.Test/DeletesTest.cs
+++ b/tests/TileDB.CSharp.Test/DeletesTest.cs
@@ -50,7 +50,7 @@ private static void DeleteFour(Context ctx, Array array, LayoutType layout, bool
         {
             // Delete multiple cells at once
             array.Open(QueryType.Delete);
-            using var deleteQuery = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery = new Query(array, QueryType.Delete);
             using var notCondition = QueryCondition.Create(ctx, "cols", 3, QueryConditionOperatorType.NotEqual);
             using var andCondition = QueryCondition.Create(ctx, "cols", 2, QueryConditionOperatorType.GreaterThan);
             using var queryCondition = notCondition & andCondition;
@@ -127,7 +127,7 @@ public void SingleCell(LayoutType layout, string queryReader, bool duplicates)
 
             // Delete one cell
             array.Open(QueryType.Delete);
-            using var deleteQuery = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery = new Query(array, QueryType.Delete);
             using var colsCondition = QueryCondition.Create(ctx, "cols", 1, QueryConditionOperatorType.Equal);
             using var rowsCondition = QueryCondition.Create(ctx, "rows", 1, QueryConditionOperatorType.Equal);
             using var andCondition = colsCondition & rowsCondition;
@@ -180,7 +180,7 @@ public void VaryingCells(LayoutType layout, string queryReader, bool duplicates)
 
             // Delete 1 cell
             array.Open(QueryType.Delete);
-            using var deleteQuery = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery = new Query(array, QueryType.Delete);
             using var colsCondition = QueryCondition.Create(ctx, "cols", 1, QueryConditionOperatorType.Equal);
             using var rowsCondition = QueryCondition.Create(ctx, "rows", 1, QueryConditionOperatorType.Equal);
             using var andCondition = colsCondition & rowsCondition;
@@ -203,7 +203,7 @@ public void VaryingCells(LayoutType layout, string queryReader, bool duplicates)
             // + The OR condition overlaps on (3, 4)
             // + (3, 2) was deleted by a previous delete query
             array.Open(QueryType.Delete);
-            using var deleteQuery2 = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery2 = new Query(array, QueryType.Delete);
             using var colsCondition2 = QueryCondition.Create(ctx, "cols", 4, QueryConditionOperatorType.Equal);
             using var rowsCondition2 = QueryCondition.Create(ctx, "rows", 3, QueryConditionOperatorType.Equal);
             using var orCondition = colsCondition2 | rowsCondition2;
@@ -246,7 +246,7 @@ public void MultipleFragments(LayoutType layout, string queryReader, bool duplic
 
             // Delete single cell
             array.Open(QueryType.Delete);
-            using var deleteQuery = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery = new Query(array, QueryType.Delete);
             using var rowsCondition = QueryCondition.Create(ctx, "rows", 1, QueryConditionOperatorType.Equal);
             using var colsCondition = QueryCondition.Create(ctx, "cols", 1, QueryConditionOperatorType.Equal);
             using var andCondition = rowsCondition & colsCondition;
@@ -437,7 +437,7 @@ public void SchemaEvolution(LayoutType layout, string queryReader, bool duplicat
             delArray.SetOpenTimestampStart(deleteTime);
             delArray.SetOpenTimestampEnd(deleteTime);
             delArray.Open(QueryType.Delete);
-            using var deleteQuery = new Query(ctx, delArray, QueryType.Delete);
+            using var deleteQuery = new Query(delArray, QueryType.Delete);
             using var rowsCondition = QueryCondition.Create(ctx, "rows", 1, QueryConditionOperatorType.Equal);
             using var colsCondition = QueryCondition.Create(ctx, "cols", 1, QueryConditionOperatorType.Equal);
             using var andCondition = rowsCondition & colsCondition;
@@ -577,7 +577,7 @@ public void SchemaEvolution(LayoutType layout, string queryReader, bool duplicat
 
             // Make a delete condition on an attribute
             array.Open(QueryType.Delete);
-            using var deleteQuery2 = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery2 = new Query(array, QueryType.Delete);
             using var attrCondition = QueryCondition.Create(ctx, "a1", 10, QueryConditionOperatorType.LessThan);
             deleteQuery2.SetCondition(attrCondition);
             deleteQuery2.Submit();
@@ -672,7 +672,7 @@ public void SameFragment(LayoutType layout, string queryReader, bool duplicates)
             array.SetOpenTimestampEnd(writeTime.Item1);
             array.Open(QueryType.Delete);
             Logger.LogMessage($"Array opened at between {array.OpenTimestampStart()} and {array.OpenTimestampEnd()}");
-            using var deleteQuery = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery = new Query(array, QueryType.Delete);
             using var attrCondition = QueryCondition.Create(ctx, "a1", 17, QueryConditionOperatorType.Equal);
             deleteQuery.SetCondition(attrCondition);
             deleteQuery.Submit();
@@ -765,7 +765,7 @@ public void SequenceTest(LayoutType layout, string queryReader, bool duplicates)
             }
 
             array.Open(QueryType.Delete);
-            using var deleteQuery = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery = new Query(array, QueryType.Delete);
             using var attrCondition = QueryCondition.Create(ctx, "a0", 4, QueryConditionOperatorType.Equal);
             deleteQuery.SetCondition(attrCondition);
             deleteQuery.Submit();
@@ -858,7 +858,7 @@ public void TestStrings(LayoutType layout, string queryReader, bool duplicates)
             }
 
             array.Open(QueryType.Delete);
-            using var deleteQuery = new Query(ctx, array, QueryType.Delete);
+            using var deleteQuery = new Query(array, QueryType.Delete);
             using var colsCondition = QueryCondition.Create(ctx, "cols", 1, QueryConditionOperatorType.Equal);
             deleteQuery.SetCondition(colsCondition);
             deleteQuery.Submit();
diff --git a/tests/TileDB.CSharp.Test/FragmentInfoTest.cs b/tests/TileDB.CSharp.Test/FragmentInfoTest.cs
index 51e7de8c..5c1ac9b3 100644
--- a/tests/TileDB.CSharp.Test/FragmentInfoTest.cs
+++ b/tests/TileDB.CSharp.Test/FragmentInfoTest.cs
@@ -427,7 +427,7 @@ private void WriteDenseArray(string arrayUri)
 
             using Array array = new Array(_ctx, arrayUri);
             array.Open(QueryType.Write);
-            using Query query = new Query(_ctx, array);
+            using Query query = new Query(array);
             query.SetDataBuffer("a", data);
             using Subarray subarray = new Subarray(array);
             subarray.SetSubarray(1, 2, 1, 4);
@@ -463,7 +463,7 @@ private void WriteSparseVarDimArray(string arrayUri)
 
             using Array array = new Array(_ctx, arrayUri);
             array.Open(QueryType.Write);
-            using Query query = new Query(_ctx, array);
+            using Query query = new Query(array);
             query.SetLayout(LayoutType.GlobalOrder);
 
             query.SetDataBuffer("d1", dData);
@@ -529,7 +529,7 @@ private void WriteSparseArrayNoVarDim3Frags(string arrayUri)
 
             void WriteImpl(long[] d1, long[] d2, int[] a1)
             {
-                using Query query = new Query(_ctx, a);
+                using Query query = new Query(a);
                 query.SetLayout(LayoutType.Unordered);
                 query.SetDataBuffer("d1", d1);
                 query.SetDataBuffer("d2", d2);
@@ -551,7 +551,7 @@ private void WriteSparseArrayNoVarDim3FragsInt32(string arrayUri)
 
             void WriteImpl(int[] d1, int[] d2, int[] a1)
             {
-                using Query query = new Query(_ctx, a);
+                using Query query = new Query(a);
                 query.SetLayout(LayoutType.Unordered);
                 query.SetDataBuffer("d1", d1);
                 query.SetDataBuffer("d2", d2);
@@ -588,7 +588,7 @@ private void WriteSparseVarDimArrayForMbrTesting(string arrayUri)
 
             using Array array = new Array(_ctx, arrayUri);
             array.Open(QueryType.Write);
-            using Query query = new Query(_ctx, array);
+            using Query query = new Query(array);
             query.SetLayout(LayoutType.Unordered);
 
             query.SetDataBuffer("d", dData);
diff --git a/tests/TileDB.CSharp.Test/IncompleteQueryTest.cs b/tests/TileDB.CSharp.Test/IncompleteQueryTest.cs
index 0a6c322b..d7ff498c 100644
--- a/tests/TileDB.CSharp.Test/IncompleteQueryTest.cs
+++ b/tests/TileDB.CSharp.Test/IncompleteQueryTest.cs
@@ -42,7 +42,7 @@ private static void WriteArray(string path, Entry[] data)
             using (var array_write = new Array(Ctx, path))
             {
                 array_write.Open(QueryType.Write);
-                var query_write = new Query(Ctx, array_write);
+                var query_write = new Query(array_write);
                 query_write.SetLayout(LayoutType.Unordered);
                 query_write.SetDataBuffer("rows", dim1_data_buffer);
                 query_write.SetDataBuffer("cols", dim2_data_buffer);
@@ -65,7 +65,7 @@ private static List<Entry> ReadArray(string path)
             using (var array_read = new Array(Ctx, path))
             {
                 array_read.Open(QueryType.Read);
-                var query_read = new Query(Ctx, array_read);
+                var query_read = new Query(array_read);
                 query_read.SetLayout(LayoutType.Unordered);
                 query_read.SetDataBuffer("rows", dim1_data_buffer_read);
                 query_read.SetDataBuffer("cols", dim2_data_buffer_read);
diff --git a/tests/TileDB.CSharp.Test/QueryConditionTest.cs b/tests/TileDB.CSharp.Test/QueryConditionTest.cs
index c2d78e0b..ff7bbebb 100644
--- a/tests/TileDB.CSharp.Test/QueryConditionTest.cs
+++ b/tests/TileDB.CSharp.Test/QueryConditionTest.cs
@@ -52,7 +52,7 @@ public void TestSimpleQueryCondition()
 
             array_write.Open(QueryType.Write);
 
-            using var query_write = new Query(context, array_write);
+            using var query_write = new Query(array_write);
 
             var attr1_data_buffer = new int[16] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
             query_write.SetDataBuffer("a1", attr1_data_buffer);
@@ -69,7 +69,7 @@ public void TestSimpleQueryCondition()
 
             array_read.Open(QueryType.Read);
 
-            using var query_read = new Query(context, array_read);
+            using var query_read = new Query(array_read);
 
             query_read.SetLayout(LayoutType.RowMajor);
 
@@ -99,6 +99,100 @@ public void TestSimpleQueryCondition()
             // Assert.AreEqual<int>(6, attr_data_buffer_read[2]);
         }
 
+        [TestMethod]
+        public void TestNegateQueryCondition()
+        {
+            var context = Context.GetDefault();
+            Assert.IsNotNull(context);
+
+            using var dimension1 = Dimension.Create(context, "rows", 1, 4, 2);
+            Assert.IsNotNull(dimension1);
+
+            using var dimension2 = Dimension.Create(context, "cols", 1, 4, 2);
+            Assert.IsNotNull(dimension2);
+
+            using var domain = new Domain(context);
+            Assert.IsNotNull(domain);
+
+            domain.AddDimension(dimension1);
+            domain.AddDimension(dimension2);
+
+            using var array_schema = new ArraySchema(context, ArrayType.Dense);
+            Assert.IsNotNull(array_schema);
+
+
+            using var attr1 = new Attribute(context, "a1", DataType.Int32);
+            Assert.IsNotNull(attr1);
+
+            array_schema.AddAttribute(attr1);
+
+            array_schema.SetDomain(domain);
+
+            array_schema.Check();
+
+            var tmpArrayPath = TestUtil.MakeTestPath("tiledb_test_sparse_array");
+
+            if (Directory.Exists(tmpArrayPath))
+            {
+                Directory.Delete(tmpArrayPath, true);
+            }
+
+            Array.Create(context, tmpArrayPath, array_schema);
+
+            //Write array
+            using var array_write = new Array(context, tmpArrayPath);
+            Assert.IsNotNull(array_write);
+
+            array_write.Open(QueryType.Write);
+
+            using var query_write = new Query(array_write);
+
+            var attr1_data_buffer = new int[16] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
+            query_write.SetDataBuffer("a1", attr1_data_buffer);
+            query_write.Submit();
+
+            var status = query_write.Status();
+
+            Assert.AreEqual(QueryStatus.Completed, status);
+
+            array_write.Close();
+
+            using var array_read = new Array(context, tmpArrayPath);
+            Assert.IsNotNull(array_read);
+
+            array_read.Open(QueryType.Read);
+
+            using var query_read = new Query(array_read);
+
+            query_read.SetLayout(LayoutType.RowMajor);
+
+            using var subarray = new Subarray(array_read);
+            subarray.SetSubarray(1, 4, 1, 4);
+            query_read.SetSubarray(subarray);
+
+            using QueryCondition qc1 = QueryCondition.Create(context, "a1", 3, QueryConditionOperatorType.GreaterThan);
+            using QueryCondition qc2 = QueryCondition.Create(context, "a1", 7, QueryConditionOperatorType.LessThan);
+            using QueryCondition qc3 = qc1 & qc2;
+            using QueryCondition qc = !qc3;
+
+            query_read.SetCondition(qc);
+
+            var attr_data_buffer_read = new int[16];
+            query_read.SetDataBuffer("a1", attr_data_buffer_read);
+
+            query_read.Submit();
+            var status_read = query_read.Status();
+
+            Assert.AreEqual(QueryStatus.Completed, status_read);
+
+            array_read.Close();
+
+            // the result query buffer for !(3<x<7) should be 1,2,3,<FILL>,<FILL>,<FILL>7,8,9,10,11,12,13,14,15,16
+            Assert.AreEqual(int.MinValue, attr_data_buffer_read[3]);
+            Assert.AreEqual(int.MinValue, attr_data_buffer_read[4]);
+            Assert.AreEqual(int.MinValue, attr_data_buffer_read[5]);
+        }
+
         [TestMethod]
         public void TestIsNotNullCondition()
         {
@@ -130,7 +224,7 @@ public void TestIsNotNullCondition()
 
             array_write.Open(QueryType.Write);
 
-            using var query_write = new Query(context, array_write);
+            using var query_write = new Query(array_write);
 
             var attr_data_buffer = new int[] { 1, 2, 3, 4, 5 };
             var attr_validity_buffer = new byte[] { 1, 1, 0, 1, 1 };
@@ -149,7 +243,7 @@ public void TestIsNotNullCondition()
 
             array_read.Open(QueryType.Read);
 
-            using var query_read = new Query(context, array_read);
+            using var query_read = new Query(array_read);
 
             query_read.SetLayout(LayoutType.RowMajor);
 
diff --git a/tests/TileDB.CSharp.Test/QueryTest.cs b/tests/TileDB.CSharp.Test/QueryTest.cs
index decaa1fa..92b2a6cf 100644
--- a/tests/TileDB.CSharp.Test/QueryTest.cs
+++ b/tests/TileDB.CSharp.Test/QueryTest.cs
@@ -44,7 +44,7 @@ public void TestGlobalQuery(LayoutType layoutType, ArrayType arrayType)
             // Write array
             array.Open(QueryType.Write);
             Assert.IsTrue(array.IsOpen());
-            using var queryWrite = new Query(ctx, array);
+            using var queryWrite = new Query(array);
             queryWrite.SetLayout(layoutType);
             if (arrayType == ArrayType.Dense)
             {
@@ -74,7 +74,7 @@ public void TestGlobalQuery(LayoutType layoutType, ArrayType arrayType)
             // Read array
             array.Open(QueryType.Read);
             Assert.IsTrue(array.IsOpen());
-            using var queryRead = new Query(ctx, array);
+            using var queryRead = new Query(array);
             // Initially allocate buffers for dense read
             var a1Read = new int[16];
             var rowsRead = new int[16];
@@ -176,7 +176,7 @@ public void TestDenseQuery()
 
             array.Open(QueryType.Write);
 
-            var query = new Query(context, array);
+            var query = new Query(array);
 
             using (var subarray = new Subarray(array))
             {
@@ -216,7 +216,7 @@ public void TestDenseQuery()
 
             array_read.Open(QueryType.Read);
 
-            var query_read = new Query(context, array_read);
+            var query_read = new Query(array_read);
 
             using (var subarray = new Subarray(array_read))
             {
@@ -310,7 +310,7 @@ public void TestSimpleSparseArrayQuery()
 
                 array_write.Open(QueryType.Write);
 
-                var query_write = new Query(context, array_write);
+                var query_write = new Query(array_write);
 
                 query_write.SetLayout(LayoutType.Unordered);
 
@@ -339,7 +339,7 @@ public void TestSimpleSparseArrayQuery()
 
                 array_read.Open(QueryType.Read);
 
-                var query_read = new Query(context, array_read);
+                var query_read = new Query(array_read);
 
                 query_read.SetLayout(LayoutType.RowMajor);
 
@@ -454,7 +454,7 @@ public unsafe void TestNullableAttributeArrayQuery()
 
                 array_write.Open(QueryType.Write);
 
-                using var query_write = new Query(context, array_write);
+                using var query_write = new Query(array_write);
                 query_write.SetLayout(LayoutType.RowMajor);
 
                 query_write.SetDataBuffer("a1", a1_data_ptr, (ulong)a1_data.Length);
@@ -495,7 +495,7 @@ public unsafe void TestNullableAttributeArrayQuery()
 
                 array_read.Open(QueryType.Read);
 
-                using var query_read = new Query(context, array_read);
+                using var query_read = new Query(array_read);
 
                 query_read.SetLayout(LayoutType.RowMajor);
                 using var subarray = new Subarray(array_read);
@@ -576,7 +576,7 @@ public void TestBoolAttributeArrayQuery()
             array_write.Create(array_schema);
             array_write.Open(QueryType.Write);
 
-            var query_write = new Query(context, array_write);
+            var query_write = new Query(array_write);
             using (var subarray = new Subarray(array_write))
             {
                 subarray.SetSubarray(1, 2, 1, 2);
@@ -599,7 +599,7 @@ public void TestBoolAttributeArrayQuery()
             Assert.IsNotNull(array_read);
             array_read.Open(QueryType.Read);
 
-            var query_read = new Query(context, array_read);
+            var query_read = new Query(array_read);
             using (var subarray = new Subarray(array_read))
             {
                 subarray.SetSubarray(1, 2, 1, 2);
@@ -619,7 +619,7 @@ public void TestBoolAttributeArrayQuery()
             query_read.Dispose();
 
             // Read from array into byte[]
-            query_read = new Query(context, array_read);
+            query_read = new Query(array_read);
             using (var subarray = new Subarray(array_read))
             {
                 subarray.SetSubarray(1, 2, 1, 2);
@@ -670,14 +670,14 @@ public void TestMemoryHandleGetsUnpinned()
             // From the documentation, the memory will be unpinned if:
 
             // the query is disposed,
-            using (var q = new Query(context, array))
+            using (var q = new Query(array))
             {
                 q.UnsafeSetDataBuffer("rows", disposalCanary.Memory.Pin(), 1 * sizeof(int));
             }
             Assert.AreEqual(1, disposalCanary.UnpinCount);
 
             // the buffer is reassigned,
-            using (var q = new Query(context, array))
+            using (var q = new Query(array))
             {
                 q.UnsafeSetDataBuffer("rows", disposalCanary.Memory.Pin(), 1 * sizeof(int));
                 q.SetDataBuffer("rows", new int[1]);
@@ -685,7 +685,7 @@ public void TestMemoryHandleGetsUnpinned()
             }
 
             // or setting the buffer fails.
-            using (var q = new Query(context, array))
+            using (var q = new Query(array))
             {
                 Assert.ThrowsException<TileDBException>(() => q.UnsafeSetDataBuffer("foo", disposalCanary.Memory.Pin(), 1 * sizeof(int)));
                 Assert.AreEqual(3, disposalCanary.UnpinCount);
diff --git a/tests/TileDB.CSharp.Test/StatsTest.cs b/tests/TileDB.CSharp.Test/StatsTest.cs
index 015c948f..75b40f09 100644
--- a/tests/TileDB.CSharp.Test/StatsTest.cs
+++ b/tests/TileDB.CSharp.Test/StatsTest.cs
@@ -25,7 +25,7 @@ public void TestStats()
 
             var array = new Array(ctx, ArrayUri);
             array.Open(QueryType.Write);
-            var query = new Query(ctx, array);
+            var query = new Query(array);
             query.SetLayout(LayoutType.RowMajor);
             var subarray = new Subarray(array);
             subarray.SetSubarray(1, 4, 1, 4);
diff --git a/tests/TileDB.CSharp.Test/TestUtil.cs b/tests/TileDB.CSharp.Test/TestUtil.cs
index af2f7130..baed08fc 100644
--- a/tests/TileDB.CSharp.Test/TestUtil.cs
+++ b/tests/TileDB.CSharp.Test/TestUtil.cs
@@ -91,7 +91,7 @@ public static Query WriteArray(
             // Use context if provided; Else get default context
             ctx ??= Context.GetDefault();
 
-            var writeQuery = new Query(ctx, array, QueryType.Write);
+            var writeQuery = new Query(array, QueryType.Write);
             // Sparse arrays can't write using row major; Can read using row-major, but not preferred for performance
             if (array.Schema().ArrayType() == ArrayType.Sparse && layout == LayoutType.RowMajor)
             {
@@ -165,7 +165,7 @@ public static Query ReadArray(
             // Use context if provided; Else get default context
             ctx ??= Context.GetDefault();
 
-            var readQuery = new Query(ctx, array, QueryType.Read);
+            var readQuery = new Query(array, QueryType.Read);
             readQuery.SetLayout(layout);
             foreach (var buffer in buffers)
             {