diff --git a/README.md b/README.md
index 4f217e2a87ec8fd8031961ee4860f8627d5baeab..a8638022f4cf8740141b997aa7adb2ffee18ef9e 100644
--- a/README.md
+++ b/README.md
@@ -1,18 +1,37 @@
-# Metadata Extractor Cronjob
+# Coscine.MetadataExtractorCron - the C# cronjob for the Metadata Extractor API
 
 [[_TOC_]] 
 
 ## 📝 Overview
 
-This application goes daily over all resources in Coscine which have the Metadata Extraction activated and executes it. It is a metadata extractor that extracts metadata from files and stores it in a database. It is designed to be run as a cron job on a server. The extracted metadata includes information such as the title, author, and creation date of the PDF files. The program uses C#, Python and several third-party libraries to extract the metadata and interact with the database.
+This cronjob interacts with the Coscine Api and the Metadata Extraction API to extract metadata from research data.
 
-## ⚙️ Configuration
-
-Before you can run and use the script, you need to ensure that the following dependencies and prerequisites are in place:
+### Features
+- **Configuration-driven**: Behavior driven by settings defined in configuration files and environment variables (see `appsettings.json`).
+- **Logging**: Extensive logging capabilities to track the process and troubleshoot issues.
 
-1. The project's referenced .NET SDK(s) must be installed. Please refer to the project's source code for information on which .NET SDK(s) are required.
+## ⚙️ Configuration
 
-Once you have all the necessary dependencies and prerequisites in place, you should be able to run and use this script.
+The deployment script uses a configuration class `MetadataExtractorCronConfiguration` to manage settings such as:
+- `IsEnabled`: Toggles the extractor on or off.
+- `MetadataExtractionUrl`: Specifies the metadata extraction service URL.
+- `DetectionByteLimit`: Specifies limit the metadata extraction cronjob should adhere to.
+- `Logger` Configuration: Specifies the logging level and output directory.
+
+### Example `appsettings.json`
+```json
+{
+  "MetadataExtractorConfiguration": {
+    "IsEnabled": true,
+    "MetadataExtractionUrl": "https://metadataextractor.otc.coscine.dev/",
+    "DetectionByteLimit": 16000000,
+    "Logger": {
+      "LogLevel": "Trace",
+      "LogHome": "C:\\coscine\\logs\\MetadataExtractorCron\\"
+    }
+  }
+}
+```
 
 ## 📖 Usage
 
@@ -20,9 +39,11 @@ To get started with this project, you will need to ensure you have configured an
 
 1. Execute the built executable (`.exe`)
 
+To use the **MetadataExtractorCron**, execute the main program with appropriate command-line arguments to control its operation.
+
 ## 👥 Contributing
 
-As an open source plattform and project, we welcome contributions from our community in any form. You can do so by submitting bug reports or feature requests, or by directly contributing to Coscine's source code. To submit your contribution please follow our [Contributing Guideline](https://git.rwth-aachen.de/coscine/docs/public/wiki/-/blob/master/Contributing%20To%20Coscine.md).
+As an open source platform and project, we welcome contributions from our community in any form. You can do so by submitting bug reports or feature requests, or by directly contributing to Coscine's source code. To submit your contribution please follow our [Contributing Guideline](https://git.rwth-aachen.de/coscine/docs/public/wiki/-/blob/master/Contributing%20To%20Coscine.md).
 
 ## 📄 License
 
@@ -43,5 +64,3 @@ By following these simple steps, you can get the support you need to use Coscine
 
 External users can find the _Releases and Changelog_ inside each project's repository. The repository contains a section for Releases (`Deployments > Releases`), where users can find the latest release changelog and source. Withing the Changelog you can find a list of all the changes made in that particular release and version.  
 By regularly checking for new releases and changes in the Changelog, you can stay up-to-date with the latest improvements and bug fixes by our team and community!
-
-
diff --git a/generate-metadata-extractor-api-client.sh b/generate-metadata-extractor-api-client.sh
new file mode 100644
index 0000000000000000000000000000000000000000..62bbee2fe1e579b5cdee7fedb565c5a30e5fd72b
--- /dev/null
+++ b/generate-metadata-extractor-api-client.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+
+# --------------------------------------------------------------------------------------------------------------------------------------------------------------------
+# Generate C# API Client using OpenAPI Generator:
+# --------------------------------------------------------------------------------------------------------------------------------------------------------------------
+# This script generates a C# API client based on the OpenAPI specification.
+#
+# The actions performed are:
+# - Downloading the OpenAPI generator CLI tool.
+# - Generating the API client code.
+# - Deleting existing API client source files.
+# - Copying the newly generated API client source to the project directory.
+# - Replacing the README.md file.
+# - Cleaning up temporary files and the downloaded tool.
+#
+# Defined variables:
+GENERATOR_URL="https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/7.0.1/openapi-generator-cli-7.0.1.jar" # URL to the OpenAPI generator JAR file
+GENERATOR_JAR="openapi-generator-cli.jar"             # The name of the OpenAPI generator JAR file
+OUTPUT_DIR="temp"                                     # The temporary directory for generated files
+ARTIFACT_ID="Coscine.MetadataExtractor.Core"                  # The artifact ID for the API client
+PACKAGE_NAME="Coscine.MetadataExtractor.Core"                 # The package name for the API client
+API_SPEC_URL="https://metadataextractor.otc.coscine.dev/swagger.json" # URL to the OpenAPI spec file
+# --------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+# ANSI color codes for styling
+GREEN='\033[0;32m'
+YELLOW='\033[0;33m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Download the OpenAPI generator JAR file
+echo -e "${CYAN}Downloading the OpenAPI generator JAR file...${NC}"
+curl -o "$GENERATOR_JAR" "$GENERATOR_URL"
+
+# Run the OpenAPI generator
+echo -e "${CYAN}Running the OpenAPI generator...${NC}"
+java -jar "$GENERATOR_JAR" generate -i "$API_SPEC_URL" -g csharp -o "$OUTPUT_DIR" --artifact-id "$ARTIFACT_ID" --package-name "$PACKAGE_NAME" --skip-validate-spec --server-variables=host=localhost:7206,basePath=coscine
+
+echo -e "${GREEN}API client generation complete.${NC}"
+
+# Delete the current API client source
+echo -e "${YELLOW}Deleting current API client source...${NC}"
+rm -rf "src/$PACKAGE_NAME"
+rm -rf "src/${PACKAGE_NAME}.Test"
+
+# Copy the generated API client source to the src directory
+echo -e "${CYAN}Copying generated API client source to src directory...${NC}"
+cp -R "$OUTPUT_DIR/src/$PACKAGE_NAME" "src/$PACKAGE_NAME"
+cp -R "$OUTPUT_DIR/src/${PACKAGE_NAME}.Test" "src/${PACKAGE_NAME}.Test"
+
+# Remove the temp directory and the generator JAR file
+echo -e "${YELLOW}Cleaning up...${NC}"
+rm -rf "$OUTPUT_DIR"
+rm -f "$GENERATOR_JAR"
+
+echo -e "${GREEN}Finished.${NC}"
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Api/DefaultApi.cs b/src/Coscine.MetadataExtractor.Core/Api/DefaultApi.cs
similarity index 59%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Api/DefaultApi.cs
rename to src/Coscine.MetadataExtractor.Core/Api/DefaultApi.cs
index 5d5541c8dfe218eedea91d5ce8c89f5d474b3a2a..a6ee294a2b5204e36f9e30b912c4a3b474c233e3 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Api/DefaultApi.cs
+++ b/src/Coscine.MetadataExtractor.Core/Api/DefaultApi.cs
@@ -3,89 +3,97 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
-using Org.OpenAPITools.Client;
-using Org.OpenAPITools.Model;
 
-namespace Org.OpenAPITools.Api
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Net;
+using System.Net.Mime;
+using Coscine.MetadataExtractor.Core.Client;
+using Coscine.MetadataExtractor.Core.Model;
+
+namespace Coscine.MetadataExtractor.Core.Api
 {
+
     /// <summary>
     /// Represents a collection of functions to interact with the API endpoints
     /// </summary>
     public interface IDefaultApiSync : IApiAccessor
     {
         #region Synchronous Operations
-
         /// <summary>
-        ///
+        /// 
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns></returns>
         void GetConfigWorker(int operationIndex = 0);
 
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ApiResponse of Object(void)</returns>
         ApiResponse<Object> GetConfigWorkerWithHttpInfo(int operationIndex = 0);
-
         /// <summary>
-        ///
+        /// 
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ModelVersion</returns>
         ModelVersion GetVersionWorker(int operationIndex = 0);
 
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ApiResponse of ModelVersion</returns>
         ApiResponse<ModelVersion> GetVersionWorkerWithHttpInfo(int operationIndex = 0);
-
         /// <summary>
-        ///
+        /// 
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>List&lt;MetadataOutput&gt;</returns>
-        List<MetadataOutput> PostMetadataExtractorWorker(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0);
+        List<MetadataOutput> PostMetadataExtractorWorker(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0);
 
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ApiResponse of List&lt;MetadataOutput&gt;</returns>
-        ApiResponse<List<MetadataOutput>> PostMetadataExtractorWorkerWithHttpInfo(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0);
-
+        ApiResponse<List<MetadataOutput>> PostMetadataExtractorWorkerWithHttpInfo(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0);
         #endregion Synchronous Operations
     }
 
@@ -95,89 +103,89 @@ namespace Org.OpenAPITools.Api
     public interface IDefaultApiAsync : IApiAccessor
     {
         #region Asynchronous Operations
-
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of void</returns>
         System.Threading.Tasks.Task GetConfigWorkerAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
 
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ApiResponse</returns>
         System.Threading.Tasks.Task<ApiResponse<Object>> GetConfigWorkerWithHttpInfoAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
-
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ModelVersion</returns>
         System.Threading.Tasks.Task<ModelVersion> GetVersionWorkerAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
 
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ApiResponse (ModelVersion)</returns>
         System.Threading.Tasks.Task<ApiResponse<ModelVersion>> GetVersionWorkerWithHttpInfoAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
-
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of List&lt;MetadataOutput&gt;</returns>
-        System.Threading.Tasks.Task<List<MetadataOutput>> PostMetadataExtractorWorkerAsync(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
+        System.Threading.Tasks.Task<List<MetadataOutput>> PostMetadataExtractorWorkerAsync(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
 
         /// <summary>
-        ///
+        /// 
         /// </summary>
         /// <remarks>
-        ///
+        /// 
         /// </remarks>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ApiResponse (List&lt;MetadataOutput&gt;)</returns>
-        System.Threading.Tasks.Task<ApiResponse<List<MetadataOutput>>> PostMetadataExtractorWorkerWithHttpInfoAsync(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
-
+        System.Threading.Tasks.Task<ApiResponse<List<MetadataOutput>>> PostMetadataExtractorWorkerWithHttpInfoAsync(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken));
         #endregion Asynchronous Operations
     }
 
@@ -186,6 +194,7 @@ namespace Org.OpenAPITools.Api
     /// </summary>
     public interface IDefaultApi : IDefaultApiSync, IDefaultApiAsync
     {
+
     }
 
     /// <summary>
@@ -193,7 +202,7 @@ namespace Org.OpenAPITools.Api
     /// </summary>
     public partial class DefaultApi : IDefaultApi
     {
-        private Org.OpenAPITools.Client.ExceptionFactory _exceptionFactory = (name, response) => null;
+        private Coscine.MetadataExtractor.Core.Client.ExceptionFactory _exceptionFactory = (name, response) => null;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="DefaultApi"/> class.
@@ -209,13 +218,13 @@ namespace Org.OpenAPITools.Api
         /// <returns></returns>
         public DefaultApi(string basePath)
         {
-            this.Configuration = Org.OpenAPITools.Client.Configuration.MergeConfigurations(
-                Org.OpenAPITools.Client.GlobalConfiguration.Instance,
-                new Org.OpenAPITools.Client.Configuration { BasePath = basePath }
+            this.Configuration = Coscine.MetadataExtractor.Core.Client.Configuration.MergeConfigurations(
+                Coscine.MetadataExtractor.Core.Client.GlobalConfiguration.Instance,
+                new Coscine.MetadataExtractor.Core.Client.Configuration { BasePath = basePath }
             );
-            this.Client = new Org.OpenAPITools.Client.ApiClient(this.Configuration.BasePath);
-            this.AsynchronousClient = new Org.OpenAPITools.Client.ApiClient(this.Configuration.BasePath);
-            this.ExceptionFactory = Org.OpenAPITools.Client.Configuration.DefaultExceptionFactory;
+            this.Client = new Coscine.MetadataExtractor.Core.Client.ApiClient(this.Configuration.BasePath);
+            this.AsynchronousClient = new Coscine.MetadataExtractor.Core.Client.ApiClient(this.Configuration.BasePath);
+            this.ExceptionFactory = Coscine.MetadataExtractor.Core.Client.Configuration.DefaultExceptionFactory;
         }
 
         /// <summary>
@@ -224,17 +233,17 @@ namespace Org.OpenAPITools.Api
         /// </summary>
         /// <param name="configuration">An instance of Configuration</param>
         /// <returns></returns>
-        public DefaultApi(Org.OpenAPITools.Client.Configuration configuration)
+        public DefaultApi(Coscine.MetadataExtractor.Core.Client.Configuration configuration)
         {
             if (configuration == null) throw new ArgumentNullException("configuration");
 
-            this.Configuration = Org.OpenAPITools.Client.Configuration.MergeConfigurations(
-                Org.OpenAPITools.Client.GlobalConfiguration.Instance,
+            this.Configuration = Coscine.MetadataExtractor.Core.Client.Configuration.MergeConfigurations(
+                Coscine.MetadataExtractor.Core.Client.GlobalConfiguration.Instance,
                 configuration
             );
-            this.Client = new Org.OpenAPITools.Client.ApiClient(this.Configuration.BasePath);
-            this.AsynchronousClient = new Org.OpenAPITools.Client.ApiClient(this.Configuration.BasePath);
-            ExceptionFactory = Org.OpenAPITools.Client.Configuration.DefaultExceptionFactory;
+            this.Client = new Coscine.MetadataExtractor.Core.Client.ApiClient(this.Configuration.BasePath);
+            this.AsynchronousClient = new Coscine.MetadataExtractor.Core.Client.ApiClient(this.Configuration.BasePath);
+            ExceptionFactory = Coscine.MetadataExtractor.Core.Client.Configuration.DefaultExceptionFactory;
         }
 
         /// <summary>
@@ -244,7 +253,7 @@ namespace Org.OpenAPITools.Api
         /// <param name="client">The client interface for synchronous API access.</param>
         /// <param name="asyncClient">The client interface for asynchronous API access.</param>
         /// <param name="configuration">The configuration object.</param>
-        public DefaultApi(Org.OpenAPITools.Client.ISynchronousClient client, Org.OpenAPITools.Client.IAsynchronousClient asyncClient, Org.OpenAPITools.Client.IReadableConfiguration configuration)
+        public DefaultApi(Coscine.MetadataExtractor.Core.Client.ISynchronousClient client, Coscine.MetadataExtractor.Core.Client.IAsynchronousClient asyncClient, Coscine.MetadataExtractor.Core.Client.IReadableConfiguration configuration)
         {
             if (client == null) throw new ArgumentNullException("client");
             if (asyncClient == null) throw new ArgumentNullException("asyncClient");
@@ -253,18 +262,18 @@ namespace Org.OpenAPITools.Api
             this.Client = client;
             this.AsynchronousClient = asyncClient;
             this.Configuration = configuration;
-            this.ExceptionFactory = Org.OpenAPITools.Client.Configuration.DefaultExceptionFactory;
+            this.ExceptionFactory = Coscine.MetadataExtractor.Core.Client.Configuration.DefaultExceptionFactory;
         }
 
         /// <summary>
         /// The client for accessing this underlying API asynchronously.
         /// </summary>
-        public Org.OpenAPITools.Client.IAsynchronousClient AsynchronousClient { get; set; }
+        public Coscine.MetadataExtractor.Core.Client.IAsynchronousClient AsynchronousClient { get; set; }
 
         /// <summary>
         /// The client for accessing this underlying API synchronously.
         /// </summary>
-        public Org.OpenAPITools.Client.ISynchronousClient Client { get; set; }
+        public Coscine.MetadataExtractor.Core.Client.ISynchronousClient Client { get; set; }
 
         /// <summary>
         /// Gets the base path of the API client.
@@ -279,12 +288,12 @@ namespace Org.OpenAPITools.Api
         /// Gets or sets the configuration object
         /// </summary>
         /// <value>An instance of the Configuration</value>
-        public Org.OpenAPITools.Client.IReadableConfiguration Configuration { get; set; }
+        public Coscine.MetadataExtractor.Core.Client.IReadableConfiguration Configuration { get; set; }
 
         /// <summary>
         /// Provides a factory method hook for the creation of exceptions.
         /// </summary>
-        public Org.OpenAPITools.Client.ExceptionFactory ExceptionFactory
+        public Coscine.MetadataExtractor.Core.Client.ExceptionFactory ExceptionFactory
         {
             get
             {
@@ -298,9 +307,9 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns></returns>
         public void GetConfigWorker(int operationIndex = 0)
@@ -309,14 +318,14 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ApiResponse of Object(void)</returns>
-        public Org.OpenAPITools.Client.ApiResponse<Object> GetConfigWorkerWithHttpInfo(int operationIndex = 0)
+        public Coscine.MetadataExtractor.Core.Client.ApiResponse<Object> GetConfigWorkerWithHttpInfo(int operationIndex = 0)
         {
-            Org.OpenAPITools.Client.RequestOptions localVarRequestOptions = new Org.OpenAPITools.Client.RequestOptions();
+            Coscine.MetadataExtractor.Core.Client.RequestOptions localVarRequestOptions = new Coscine.MetadataExtractor.Core.Client.RequestOptions();
 
             string[] _contentTypes = new string[] {
             };
@@ -325,21 +334,23 @@ namespace Org.OpenAPITools.Api
             string[] _accepts = new string[] {
             };
 
-            var localVarContentType = Org.OpenAPITools.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
+            var localVarContentType = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
             if (localVarContentType != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
             }
 
-            var localVarAccept = Org.OpenAPITools.Client.ClientUtils.SelectHeaderAccept(_accepts);
+            var localVarAccept = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderAccept(_accepts);
             if (localVarAccept != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
             }
 
+
             localVarRequestOptions.Operation = "DefaultApi.GetConfigWorker";
             localVarRequestOptions.OperationIndex = operationIndex;
 
+
             // make the HTTP request
             var localVarResponse = this.Client.Get<Object>("/defaultConfig", localVarRequestOptions, this.Configuration);
             if (this.ExceptionFactory != null)
@@ -355,9 +366,9 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of void</returns>
@@ -367,15 +378,16 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ApiResponse</returns>
-        public async System.Threading.Tasks.Task<Org.OpenAPITools.Client.ApiResponse<Object>> GetConfigWorkerWithHttpInfoAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
+        public async System.Threading.Tasks.Task<Coscine.MetadataExtractor.Core.Client.ApiResponse<Object>> GetConfigWorkerWithHttpInfoAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
         {
-            Org.OpenAPITools.Client.RequestOptions localVarRequestOptions = new Org.OpenAPITools.Client.RequestOptions();
+
+            Coscine.MetadataExtractor.Core.Client.RequestOptions localVarRequestOptions = new Coscine.MetadataExtractor.Core.Client.RequestOptions();
 
             string[] _contentTypes = new string[] {
             };
@@ -384,21 +396,23 @@ namespace Org.OpenAPITools.Api
             string[] _accepts = new string[] {
             };
 
-            var localVarContentType = Org.OpenAPITools.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
+            var localVarContentType = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
             if (localVarContentType != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
             }
 
-            var localVarAccept = Org.OpenAPITools.Client.ClientUtils.SelectHeaderAccept(_accepts);
+            var localVarAccept = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderAccept(_accepts);
             if (localVarAccept != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
             }
 
+
             localVarRequestOptions.Operation = "DefaultApi.GetConfigWorker";
             localVarRequestOptions.OperationIndex = operationIndex;
 
+
             // make the HTTP request
             var localVarResponse = await this.AsynchronousClient.GetAsync<Object>("/defaultConfig", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false);
 
@@ -415,26 +429,26 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ModelVersion</returns>
         public ModelVersion GetVersionWorker(int operationIndex = 0)
         {
-            Org.OpenAPITools.Client.ApiResponse<ModelVersion> localVarResponse = GetVersionWorkerWithHttpInfo();
+            Coscine.MetadataExtractor.Core.Client.ApiResponse<ModelVersion> localVarResponse = GetVersionWorkerWithHttpInfo();
             return localVarResponse.Data;
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ApiResponse of ModelVersion</returns>
-        public Org.OpenAPITools.Client.ApiResponse<ModelVersion> GetVersionWorkerWithHttpInfo(int operationIndex = 0)
+        public Coscine.MetadataExtractor.Core.Client.ApiResponse<ModelVersion> GetVersionWorkerWithHttpInfo(int operationIndex = 0)
         {
-            Org.OpenAPITools.Client.RequestOptions localVarRequestOptions = new Org.OpenAPITools.Client.RequestOptions();
+            Coscine.MetadataExtractor.Core.Client.RequestOptions localVarRequestOptions = new Coscine.MetadataExtractor.Core.Client.RequestOptions();
 
             string[] _contentTypes = new string[] {
             };
@@ -444,21 +458,23 @@ namespace Org.OpenAPITools.Api
                 "application/json"
             };
 
-            var localVarContentType = Org.OpenAPITools.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
+            var localVarContentType = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
             if (localVarContentType != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
             }
 
-            var localVarAccept = Org.OpenAPITools.Client.ClientUtils.SelectHeaderAccept(_accepts);
+            var localVarAccept = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderAccept(_accepts);
             if (localVarAccept != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
             }
 
+
             localVarRequestOptions.Operation = "DefaultApi.GetVersionWorker";
             localVarRequestOptions.OperationIndex = operationIndex;
 
+
             // make the HTTP request
             var localVarResponse = this.Client.Get<ModelVersion>("/version", localVarRequestOptions, this.Configuration);
             if (this.ExceptionFactory != null)
@@ -474,28 +490,29 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ModelVersion</returns>
         public async System.Threading.Tasks.Task<ModelVersion> GetVersionWorkerAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
         {
-            Org.OpenAPITools.Client.ApiResponse<ModelVersion> localVarResponse = await GetVersionWorkerWithHttpInfoAsync(operationIndex, cancellationToken).ConfigureAwait(false);
+            Coscine.MetadataExtractor.Core.Client.ApiResponse<ModelVersion> localVarResponse = await GetVersionWorkerWithHttpInfoAsync(operationIndex, cancellationToken).ConfigureAwait(false);
             return localVarResponse.Data;
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ApiResponse (ModelVersion)</returns>
-        public async System.Threading.Tasks.Task<Org.OpenAPITools.Client.ApiResponse<ModelVersion>> GetVersionWorkerWithHttpInfoAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
+        public async System.Threading.Tasks.Task<Coscine.MetadataExtractor.Core.Client.ApiResponse<ModelVersion>> GetVersionWorkerWithHttpInfoAsync(int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
         {
-            Org.OpenAPITools.Client.RequestOptions localVarRequestOptions = new Org.OpenAPITools.Client.RequestOptions();
+
+            Coscine.MetadataExtractor.Core.Client.RequestOptions localVarRequestOptions = new Coscine.MetadataExtractor.Core.Client.RequestOptions();
 
             string[] _contentTypes = new string[] {
             };
@@ -505,21 +522,23 @@ namespace Org.OpenAPITools.Api
                 "application/json"
             };
 
-            var localVarContentType = Org.OpenAPITools.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
+            var localVarContentType = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
             if (localVarContentType != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
             }
 
-            var localVarAccept = Org.OpenAPITools.Client.ClientUtils.SelectHeaderAccept(_accepts);
+            var localVarAccept = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderAccept(_accepts);
             if (localVarAccept != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
             }
 
+
             localVarRequestOptions.Operation = "DefaultApi.GetVersionWorker";
             localVarRequestOptions.OperationIndex = operationIndex;
 
+
             // make the HTTP request
             var localVarResponse = await this.AsynchronousClient.GetAsync<ModelVersion>("/version", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false);
 
@@ -536,42 +555,46 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>List&lt;MetadataOutput&gt;</returns>
-        public List<MetadataOutput> PostMetadataExtractorWorker(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0)
+        public List<MetadataOutput> PostMetadataExtractorWorker(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0)
         {
-            Org.OpenAPITools.Client.ApiResponse<List<MetadataOutput>> localVarResponse = PostMetadataExtractorWorkerWithHttpInfo(file, identifier, config, creationDate, modificationDate);
+            Coscine.MetadataExtractor.Core.Client.ApiResponse<List<MetadataOutput>> localVarResponse = PostMetadataExtractorWorkerWithHttpInfo(accept, identifier, config, creationDate, modificationDate, url, file);
             return localVarResponse.Data;
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <returns>ApiResponse of List&lt;MetadataOutput&gt;</returns>
-        public Org.OpenAPITools.Client.ApiResponse<List<MetadataOutput>> PostMetadataExtractorWorkerWithHttpInfo(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0)
+        public Coscine.MetadataExtractor.Core.Client.ApiResponse<List<MetadataOutput>> PostMetadataExtractorWorkerWithHttpInfo(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0)
         {
-            // verify the required parameter 'file' is set
-            if (file == null)
+            // verify the required parameter 'accept' is set
+            if (accept == null)
             {
-                throw new Org.OpenAPITools.Client.ApiException(400, "Missing required parameter 'file' when calling DefaultApi->PostMetadataExtractorWorker");
+                throw new Coscine.MetadataExtractor.Core.Client.ApiException(400, "Missing required parameter 'accept' when calling DefaultApi->PostMetadataExtractorWorker");
             }
 
-            Org.OpenAPITools.Client.RequestOptions localVarRequestOptions = new Org.OpenAPITools.Client.RequestOptions();
+            Coscine.MetadataExtractor.Core.Client.RequestOptions localVarRequestOptions = new Coscine.MetadataExtractor.Core.Client.RequestOptions();
 
             string[] _contentTypes = new string[] {
                 "multipart/form-data"
@@ -582,39 +605,48 @@ namespace Org.OpenAPITools.Api
                 "application/json"
             };
 
-            var localVarContentType = Org.OpenAPITools.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
+            var localVarContentType = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
             if (localVarContentType != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
             }
 
-            var localVarAccept = Org.OpenAPITools.Client.ClientUtils.SelectHeaderAccept(_accepts);
+            var localVarAccept = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderAccept(_accepts);
             if (localVarAccept != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
             }
 
+            localVarRequestOptions.HeaderParameters.Add("accept", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(accept)); // header parameter
             if (identifier != null)
             {
-                localVarRequestOptions.FormParameters.Add("identifier", Org.OpenAPITools.Client.ClientUtils.ParameterToString(identifier)); // form parameter
+                localVarRequestOptions.FormParameters.Add("identifier", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(identifier)); // form parameter
             }
             if (config != null)
             {
-                localVarRequestOptions.FormParameters.Add("config", Org.OpenAPITools.Client.ClientUtils.ParameterToString(config)); // form parameter
+                localVarRequestOptions.FormParameters.Add("config", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(config)); // form parameter
             }
             if (creationDate != null)
             {
-                localVarRequestOptions.FormParameters.Add("creation_date", Org.OpenAPITools.Client.ClientUtils.ParameterToString(creationDate)); // form parameter
+                localVarRequestOptions.FormParameters.Add("creation_date", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(creationDate)); // form parameter
             }
             if (modificationDate != null)
             {
-                localVarRequestOptions.FormParameters.Add("modification_date", Org.OpenAPITools.Client.ClientUtils.ParameterToString(modificationDate)); // form parameter
+                localVarRequestOptions.FormParameters.Add("modification_date", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(modificationDate)); // form parameter
+            }
+            if (url != null)
+            {
+                localVarRequestOptions.FormParameters.Add("url", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(url)); // form parameter
+            }
+            if (file != null)
+            {
+                localVarRequestOptions.FileParameters.Add("file", file);
             }
-            localVarRequestOptions.FileParameters.Add("file", file);
 
             localVarRequestOptions.Operation = "DefaultApi.PostMetadataExtractorWorker";
             localVarRequestOptions.OperationIndex = operationIndex;
 
+
             // make the HTTP request
             var localVarResponse = this.Client.Post<List<MetadataOutput>>("/", localVarRequestOptions, this.Configuration);
             if (this.ExceptionFactory != null)
@@ -630,44 +662,49 @@ namespace Org.OpenAPITools.Api
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of List&lt;MetadataOutput&gt;</returns>
-        public async System.Threading.Tasks.Task<List<MetadataOutput>> PostMetadataExtractorWorkerAsync(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
+        public async System.Threading.Tasks.Task<List<MetadataOutput>> PostMetadataExtractorWorkerAsync(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
         {
-            Org.OpenAPITools.Client.ApiResponse<List<MetadataOutput>> localVarResponse = await PostMetadataExtractorWorkerWithHttpInfoAsync(file, identifier, config, creationDate, modificationDate, operationIndex, cancellationToken).ConfigureAwait(false);
+            Coscine.MetadataExtractor.Core.Client.ApiResponse<List<MetadataOutput>> localVarResponse = await PostMetadataExtractorWorkerWithHttpInfoAsync(accept, identifier, config, creationDate, modificationDate, url, file, operationIndex, cancellationToken).ConfigureAwait(false);
             return localVarResponse.Data;
         }
 
         /// <summary>
-        ///
+        ///  
         /// </summary>
-        /// <exception cref="Org.OpenAPITools.Client.ApiException">Thrown when fails to make API call</exception>
-        /// <param name="file"></param>
+        /// <exception cref="Coscine.MetadataExtractor.Core.Client.ApiException">Thrown when fails to make API call</exception>
+        /// <param name="accept"></param>
         /// <param name="identifier">File Identifier (optional)</param>
         /// <param name="config">Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) (optional)</param>
         /// <param name="creationDate">Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
         /// <param name="modificationDate">Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) (optional)</param>
+        /// <param name="url">Download URL of file (optional)</param>
+        /// <param name="file"> (optional)</param>
         /// <param name="operationIndex">Index associated with the operation.</param>
         /// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
         /// <returns>Task of ApiResponse (List&lt;MetadataOutput&gt;)</returns>
-        public async System.Threading.Tasks.Task<Org.OpenAPITools.Client.ApiResponse<List<MetadataOutput>>> PostMetadataExtractorWorkerWithHttpInfoAsync(System.IO.Stream file, string identifier = default(string), string config = default(string), string creationDate = default(string), string modificationDate = default(string), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
+        public async System.Threading.Tasks.Task<Coscine.MetadataExtractor.Core.Client.ApiResponse<List<MetadataOutput>>> PostMetadataExtractorWorkerWithHttpInfoAsync(string accept, string? identifier = default(string?), string? config = default(string?), string? creationDate = default(string?), string? modificationDate = default(string?), string? url = default(string?), System.IO.Stream? file = default(System.IO.Stream?), int operationIndex = 0, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
         {
-            // verify the required parameter 'file' is set
-            if (file == null)
+            // verify the required parameter 'accept' is set
+            if (accept == null)
             {
-                throw new Org.OpenAPITools.Client.ApiException(400, "Missing required parameter 'file' when calling DefaultApi->PostMetadataExtractorWorker");
+                throw new Coscine.MetadataExtractor.Core.Client.ApiException(400, "Missing required parameter 'accept' when calling DefaultApi->PostMetadataExtractorWorker");
             }
 
-            Org.OpenAPITools.Client.RequestOptions localVarRequestOptions = new Org.OpenAPITools.Client.RequestOptions();
+
+            Coscine.MetadataExtractor.Core.Client.RequestOptions localVarRequestOptions = new Coscine.MetadataExtractor.Core.Client.RequestOptions();
 
             string[] _contentTypes = new string[] {
                 "multipart/form-data"
@@ -678,39 +715,48 @@ namespace Org.OpenAPITools.Api
                 "application/json"
             };
 
-            var localVarContentType = Org.OpenAPITools.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
+            var localVarContentType = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
             if (localVarContentType != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
             }
 
-            var localVarAccept = Org.OpenAPITools.Client.ClientUtils.SelectHeaderAccept(_accepts);
+            var localVarAccept = Coscine.MetadataExtractor.Core.Client.ClientUtils.SelectHeaderAccept(_accepts);
             if (localVarAccept != null)
             {
                 localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
             }
 
+            localVarRequestOptions.HeaderParameters.Add("accept", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(accept)); // header parameter
             if (identifier != null)
             {
-                localVarRequestOptions.FormParameters.Add("identifier", Org.OpenAPITools.Client.ClientUtils.ParameterToString(identifier)); // form parameter
+                localVarRequestOptions.FormParameters.Add("identifier", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(identifier)); // form parameter
             }
             if (config != null)
             {
-                localVarRequestOptions.FormParameters.Add("config", Org.OpenAPITools.Client.ClientUtils.ParameterToString(config)); // form parameter
+                localVarRequestOptions.FormParameters.Add("config", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(config)); // form parameter
             }
             if (creationDate != null)
             {
-                localVarRequestOptions.FormParameters.Add("creation_date", Org.OpenAPITools.Client.ClientUtils.ParameterToString(creationDate)); // form parameter
+                localVarRequestOptions.FormParameters.Add("creation_date", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(creationDate)); // form parameter
             }
             if (modificationDate != null)
             {
-                localVarRequestOptions.FormParameters.Add("modification_date", Org.OpenAPITools.Client.ClientUtils.ParameterToString(modificationDate)); // form parameter
+                localVarRequestOptions.FormParameters.Add("modification_date", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(modificationDate)); // form parameter
+            }
+            if (url != null)
+            {
+                localVarRequestOptions.FormParameters.Add("url", Coscine.MetadataExtractor.Core.Client.ClientUtils.ParameterToString(url)); // form parameter
+            }
+            if (file != null)
+            {
+                localVarRequestOptions.FileParameters.Add("file", file);
             }
-            localVarRequestOptions.FileParameters.Add("file", file);
 
             localVarRequestOptions.Operation = "DefaultApi.PostMetadataExtractorWorker";
             localVarRequestOptions.OperationIndex = operationIndex;
 
+
             // make the HTTP request
             var localVarResponse = await this.AsynchronousClient.PostAsync<List<MetadataOutput>>("/", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false);
 
@@ -725,5 +771,6 @@ namespace Org.OpenAPITools.Api
 
             return localVarResponse;
         }
+
     }
-}
\ No newline at end of file
+}
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiClient.cs b/src/Coscine.MetadataExtractor.Core/Client/ApiClient.cs
similarity index 78%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiClient.cs
rename to src/Coscine.MetadataExtractor.Core/Client/ApiClient.cs
index fb7a6d931650b965202e39e2e03b8ed9dda59e64..ef284e35c9ac1949c3cf980cd39768e0274f9580 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/ApiClient.cs
@@ -3,13 +3,26 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
 using System.Net;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters;
+using System.Text;
+using System.Threading;
 using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Web;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 using RestSharp;
@@ -17,7 +30,7 @@ using RestSharp.Serializers;
 using RestSharpMethod = RestSharp.Method;
 using Polly;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Allows RestSharp to Serialize/Deserialize JSON using our custom logic, but only when ContentType is JSON.
@@ -25,7 +38,6 @@ namespace Org.OpenAPITools.Client
     internal class CustomJsonCodec : IRestSerializer, ISerializer, IDeserializer
     {
         private readonly IReadableConfiguration _configuration;
-        private static readonly string _contentType = "application/json";
         private readonly JsonSerializerSettings _serializerSettings = new JsonSerializerSettings
         {
             // OpenAPI generated types generally hide default constructors.
@@ -57,10 +69,10 @@ namespace Org.OpenAPITools.Client
         /// <returns>A JSON string.</returns>
         public string Serialize(object obj)
         {
-            if (obj != null && obj is Org.OpenAPITools.Model.AbstractOpenAPISchema)
+            if (obj != null && obj is Coscine.MetadataExtractor.Core.Model.AbstractOpenAPISchema)
             {
                 // the object to be serialized is an oneOf/anyOf schema
-                return ((Org.OpenAPITools.Model.AbstractOpenAPISchema)obj).ToJson();
+                return ((Coscine.MetadataExtractor.Core.Model.AbstractOpenAPISchema)obj).ToJson();
             }
             else
             {
@@ -138,17 +150,13 @@ namespace Org.OpenAPITools.Client
         public ISerializer Serializer => this;
         public IDeserializer Deserializer => this;
 
-        public string[] AcceptedContentTypes => RestSharp.Serializers.ContentType.JsonAccept;
+        public string[] AcceptedContentTypes => RestSharp.ContentType.JsonAccept;
 
         public SupportsContentType SupportsContentType => contentType =>
-            contentType.EndsWith("json", StringComparison.InvariantCultureIgnoreCase) ||
-            contentType.EndsWith("javascript", StringComparison.InvariantCultureIgnoreCase);
+            contentType.Value.EndsWith("json", StringComparison.InvariantCultureIgnoreCase) ||
+            contentType.Value.EndsWith("javascript", StringComparison.InvariantCultureIgnoreCase);
 
-        public string ContentType
-        {
-            get { return _contentType; }
-            set { throw new InvalidOperationException("Not allowed to set content type."); }
-        }
+        public ContentType ContentType { get; set; } = RestSharp.ContentType.Json;
 
         public DataFormat DataFormat => DataFormat.Json;
     }
@@ -195,7 +203,7 @@ namespace Org.OpenAPITools.Client
         /// </summary>
         public ApiClient()
         {
-            _baseUrl = Org.OpenAPITools.Client.GlobalConfiguration.Instance.BasePath;
+            _baseUrl = Coscine.MetadataExtractor.Core.Client.GlobalConfiguration.Instance.BasePath;
         }
 
         /// <summary>
@@ -421,7 +429,7 @@ namespace Org.OpenAPITools.Client
             return transformed;
         }
 
-        private ApiResponse<T> Exec<T>(RestRequest req, RequestOptions options, IReadableConfiguration configuration)
+        private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration)
         {
             var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
 
@@ -441,93 +449,95 @@ namespace Org.OpenAPITools.Client
                 CookieContainer = cookies,
                 MaxTimeout = configuration.Timeout,
                 Proxy = configuration.Proxy,
-                UserAgent = configuration.UserAgent
+                UserAgent = configuration.UserAgent,
+                UseDefaultCredentials = configuration.UseDefaultCredentials,
+                RemoteCertificateValidationCallback = configuration.RemoteCertificateValidationCallback
             };
 
-            RestClient client = new RestClient(clientOptions)
-                .UseSerializer(() => new CustomJsonCodec(SerializerSettings, configuration));
-
-            InterceptRequest(req);
-
-            RestResponse<T> response;
-            if (RetryConfiguration.RetryPolicy != null)
+            using (RestClient client = new RestClient(clientOptions,
+                configureSerialization: serializerConfig => serializerConfig.UseSerializer(() => new CustomJsonCodec(SerializerSettings, configuration))))
             {
-                var policy = RetryConfiguration.RetryPolicy;
-                var policyResult = policy.ExecuteAndCapture(() => client.Execute(req));
-                response = (policyResult.Outcome == OutcomeType.Successful) ? client.Deserialize<T>(policyResult.Result) : new RestResponse<T>
+                InterceptRequest(request);
+
+                RestResponse<T> response;
+                if (RetryConfiguration.RetryPolicy != null)
                 {
-                    Request = req,
-                    ErrorException = policyResult.FinalException
-                };
-            }
-            else
-            {
-                response = client.Execute<T>(req);
-            }
+                    var policy = RetryConfiguration.RetryPolicy;
+                    var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
+                    response = (policyResult.Outcome == OutcomeType.Successful) ? client.Deserialize<T>(policyResult.Result) : new RestResponse<T>(request)
+                    {
+                        ErrorException = policyResult.FinalException
+                    };
+                }
+                else
+                {
+                    response = client.Execute<T>(request);
+                }
 
-            // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
-            if (typeof(Org.OpenAPITools.Model.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
-            {
-                try
+                // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
+                if (typeof(Coscine.MetadataExtractor.Core.Model.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
                 {
-                    response.Data = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
+                    try
+                    {
+                        response.Data = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
+                    }
+                    catch (Exception ex)
+                    {
+                        throw ex.InnerException != null ? ex.InnerException : ex;
+                    }
                 }
-                catch (Exception ex)
+                else if (typeof(T).Name == "Stream") // for binary response
                 {
-                    throw ex.InnerException != null ? ex.InnerException : ex;
+                    response.Data = (T)(object)new MemoryStream(response.RawBytes);
+                }
+                else if (typeof(T).Name == "Byte[]") // for byte response
+                {
+                    response.Data = (T)(object)response.RawBytes;
+                }
+                else if (typeof(T).Name == "String") // for string response
+                {
+                    response.Data = (T)(object)response.Content;
                 }
-            }
-            else if (typeof(T).Name == "Stream") // for binary response
-            {
-                response.Data = (T)(object)new MemoryStream(response.RawBytes);
-            }
-            else if (typeof(T).Name == "Byte[]") // for byte response
-            {
-                response.Data = (T)(object)response.RawBytes;
-            }
-            else if (typeof(T).Name == "String") // for string response
-            {
-                response.Data = (T)(object)response.Content;
-            }
 
-            InterceptResponse(req, response);
+                InterceptResponse(request, response);
 
-            var result = ToApiResponse(response);
-            if (response.ErrorMessage != null)
-            {
-                result.ErrorText = response.ErrorMessage;
-            }
+                var result = ToApiResponse(response);
+                if (response.ErrorMessage != null)
+                {
+                    result.ErrorText = response.ErrorMessage;
+                }
 
-            if (response.Cookies != null && response.Cookies.Count > 0)
-            {
-                if (result.Cookies == null) result.Cookies = new List<Cookie>();
-                foreach (var restResponseCookie in response.Cookies.Cast<Cookie>())
+                if (response.Cookies != null && response.Cookies.Count > 0)
                 {
-                    var cookie = new Cookie(
-                        restResponseCookie.Name,
-                        restResponseCookie.Value,
-                        restResponseCookie.Path,
-                        restResponseCookie.Domain
-                    )
+                    if (result.Cookies == null) result.Cookies = new List<Cookie>();
+                    foreach (var restResponseCookie in response.Cookies.Cast<Cookie>())
                     {
-                        Comment = restResponseCookie.Comment,
-                        CommentUri = restResponseCookie.CommentUri,
-                        Discard = restResponseCookie.Discard,
-                        Expired = restResponseCookie.Expired,
-                        Expires = restResponseCookie.Expires,
-                        HttpOnly = restResponseCookie.HttpOnly,
-                        Port = restResponseCookie.Port,
-                        Secure = restResponseCookie.Secure,
-                        Version = restResponseCookie.Version
-                    };
-
-                    result.Cookies.Add(cookie);
+                        var cookie = new Cookie(
+                            restResponseCookie.Name,
+                            restResponseCookie.Value,
+                            restResponseCookie.Path,
+                            restResponseCookie.Domain
+                        )
+                        {
+                            Comment = restResponseCookie.Comment,
+                            CommentUri = restResponseCookie.CommentUri,
+                            Discard = restResponseCookie.Discard,
+                            Expired = restResponseCookie.Expired,
+                            Expires = restResponseCookie.Expires,
+                            HttpOnly = restResponseCookie.HttpOnly,
+                            Port = restResponseCookie.Port,
+                            Secure = restResponseCookie.Secure,
+                            Version = restResponseCookie.Version
+                        };
+
+                        result.Cookies.Add(cookie);
+                    }
                 }
+                return result;
             }
-            return result;
         }
 
-        private async Task<ApiResponse<T>> ExecAsync<T>(RestRequest req, RequestOptions options, IReadableConfiguration configuration, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
+        private async Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
         {
             var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
 
@@ -536,79 +546,80 @@ namespace Org.OpenAPITools.Client
                 ClientCertificates = configuration.ClientCertificates,
                 MaxTimeout = configuration.Timeout,
                 Proxy = configuration.Proxy,
-                UserAgent = configuration.UserAgent
+                UserAgent = configuration.UserAgent,
+                UseDefaultCredentials = configuration.UseDefaultCredentials
             };
 
-            RestClient client = new RestClient(clientOptions)
-                .UseSerializer(() => new CustomJsonCodec(SerializerSettings, configuration));
-
-            InterceptRequest(req);
-
-            RestResponse<T> response;
-            if (RetryConfiguration.AsyncRetryPolicy != null)
+            using (RestClient client = new RestClient(clientOptions,
+                configureSerialization: serializerConfig => serializerConfig.UseSerializer(() => new CustomJsonCodec(SerializerSettings, configuration))))
             {
-                var policy = RetryConfiguration.AsyncRetryPolicy;
-                var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(req, ct), cancellationToken).ConfigureAwait(false);
-                response = (policyResult.Outcome == OutcomeType.Successful) ? client.Deserialize<T>(policyResult.Result) : new RestResponse<T>
+                InterceptRequest(request);
+
+                RestResponse<T> response;
+                if (RetryConfiguration.AsyncRetryPolicy != null)
                 {
-                    Request = req,
-                    ErrorException = policyResult.FinalException
-                };
-            }
-            else
-            {
-                response = await client.ExecuteAsync<T>(req, cancellationToken).ConfigureAwait(false);
-            }
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    response = (policyResult.Outcome == OutcomeType.Successful) ? client.Deserialize<T>(policyResult.Result) : new RestResponse<T>(request)
+                    {
+                        ErrorException = policyResult.FinalException
+                    };
+                }
+                else
+                {
+                    response = await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
 
-            // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
-            if (typeof(Org.OpenAPITools.Model.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
-            {
-                response.Data = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
-            }
-            else if (typeof(T).Name == "Stream") // for binary response
-            {
-                response.Data = (T)(object)new MemoryStream(response.RawBytes);
-            }
-            else if (typeof(T).Name == "Byte[]") // for byte response
-            {
-                response.Data = (T)(object)response.RawBytes;
-            }
+                // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
+                if (typeof(Coscine.MetadataExtractor.Core.Model.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
+                {
+                    response.Data = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
+                }
+                else if (typeof(T).Name == "Stream") // for binary response
+                {
+                    response.Data = (T)(object)new MemoryStream(response.RawBytes);
+                }
+                else if (typeof(T).Name == "Byte[]") // for byte response
+                {
+                    response.Data = (T)(object)response.RawBytes;
+                }
 
-            InterceptResponse(req, response);
+                InterceptResponse(request, response);
 
-            var result = ToApiResponse(response);
-            if (response.ErrorMessage != null)
-            {
-                result.ErrorText = response.ErrorMessage;
-            }
+                var result = ToApiResponse(response);
+                if (response.ErrorMessage != null)
+                {
+                    result.ErrorText = response.ErrorMessage;
+                }
 
-            if (response.Cookies != null && response.Cookies.Count > 0)
-            {
-                if (result.Cookies == null) result.Cookies = new List<Cookie>();
-                foreach (var restResponseCookie in response.Cookies.Cast<Cookie>())
+                if (response.Cookies != null && response.Cookies.Count > 0)
                 {
-                    var cookie = new Cookie(
-                        restResponseCookie.Name,
-                        restResponseCookie.Value,
-                        restResponseCookie.Path,
-                        restResponseCookie.Domain
-                    )
+                    if (result.Cookies == null) result.Cookies = new List<Cookie>();
+                    foreach (var restResponseCookie in response.Cookies.Cast<Cookie>())
                     {
-                        Comment = restResponseCookie.Comment,
-                        CommentUri = restResponseCookie.CommentUri,
-                        Discard = restResponseCookie.Discard,
-                        Expired = restResponseCookie.Expired,
-                        Expires = restResponseCookie.Expires,
-                        HttpOnly = restResponseCookie.HttpOnly,
-                        Port = restResponseCookie.Port,
-                        Secure = restResponseCookie.Secure,
-                        Version = restResponseCookie.Version
-                    };
-
-                    result.Cookies.Add(cookie);
+                        var cookie = new Cookie(
+                            restResponseCookie.Name,
+                            restResponseCookie.Value,
+                            restResponseCookie.Path,
+                            restResponseCookie.Domain
+                        )
+                        {
+                            Comment = restResponseCookie.Comment,
+                            CommentUri = restResponseCookie.CommentUri,
+                            Discard = restResponseCookie.Discard,
+                            Expired = restResponseCookie.Expired,
+                            Expires = restResponseCookie.Expires,
+                            HttpOnly = restResponseCookie.HttpOnly,
+                            Port = restResponseCookie.Port,
+                            Secure = restResponseCookie.Secure,
+                            Version = restResponseCookie.Version
+                        };
+
+                        result.Cookies.Add(cookie);
+                    }
                 }
+                return result;
             }
-            return result;
         }
 
         #region IAsynchronousClient
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiException.cs b/src/Coscine.MetadataExtractor.Core/Client/ApiException.cs
similarity index 95%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiException.cs
rename to src/Coscine.MetadataExtractor.Core/Client/ApiException.cs
index 7044ec96e8efba560fa3726d12fe984f927b59d7..2b223072447d85f9d8b0a744f6636eb511afc265 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiException.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/ApiException.cs
@@ -3,11 +3,14 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
-namespace Org.OpenAPITools.Client
+
+using System;
+
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// API Exception
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiResponse.cs b/src/Coscine.MetadataExtractor.Core/Client/ApiResponse.cs
similarity index 97%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiResponse.cs
rename to src/Coscine.MetadataExtractor.Core/Client/ApiResponse.cs
index e94761bc7c2c4698dfa95cf5be37f958f088de49..042eaca2b7f8a50192ff7a89a5471e88f5138aec 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ApiResponse.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/ApiResponse.cs
@@ -3,14 +3,16 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
+using System.Collections.Generic;
 using System.Net;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Provides a non-generic contract for the ApiResponse wrapper.
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ClientUtils.cs b/src/Coscine.MetadataExtractor.Core/Client/ClientUtils.cs
similarity index 77%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ClientUtils.cs
rename to src/Coscine.MetadataExtractor.Core/Client/ClientUtils.cs
index f18d4d0f263180f05c6d46e84d02b61821d06728..073c72b576fcbd4016274e100871dc7fd266aa2b 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ClientUtils.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/ClientUtils.cs
@@ -3,15 +3,22 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
+
+using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
 using System.Text.RegularExpressions;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Utility functions providing some benefit to API client consumers.
@@ -50,15 +57,13 @@ namespace Org.OpenAPITools.Client
             }
             else if (value is IDictionary dictionary)
             {
-                if (collectionFormat == "deepObject")
-                {
+                if(collectionFormat == "deepObject") {
                     foreach (DictionaryEntry entry in dictionary)
                     {
                         parameters.Add(name + "[" + entry.Key + "]", ParameterToString(entry.Value));
                     }
                 }
-                else
-                {
+                else {
                     foreach (DictionaryEntry entry in dictionary)
                     {
                         parameters.Add(entry.Key.ToString(), ParameterToString(entry.Value));
@@ -97,8 +102,14 @@ namespace Org.OpenAPITools.Client
                 return dateTimeOffset.ToString((configuration ?? GlobalConfiguration.Instance).DateTimeFormat);
             if (obj is bool boolean)
                 return boolean ? "true" : "false";
-            if (obj is ICollection collection)
-                return string.Join(",", collection.Cast<object>());
+            if (obj is ICollection collection) {
+                List<string> entries = new List<string>();
+                foreach (var entry in collection)
+                    entries.Add(ParameterToString(entry, configuration));
+                return string.Join(",", entries);
+            }
+            if (obj is Enum && HasEnumMemberAttrValue(obj))
+                return GetEnumMemberAttrValue(obj);
 
             return Convert.ToString(obj, CultureInfo.InvariantCulture);
         }
@@ -197,5 +208,40 @@ namespace Org.OpenAPITools.Client
 
             return JsonRegex.IsMatch(mime) || mime.Equals("application/json-patch+json");
         }
+
+        /// <summary>
+        /// Is the Enum decorated with EnumMember Attribute
+        /// </summary>
+        /// <param name="enumVal"></param>
+        /// <returns>true if found</returns>
+        private static bool HasEnumMemberAttrValue(object enumVal)
+        {
+            if (enumVal == null)
+                throw new ArgumentNullException(nameof(enumVal));
+            var enumType = enumVal.GetType();
+            var memInfo = enumType.GetMember(enumVal.ToString() ?? throw new InvalidOperationException());
+            var attr = memInfo.FirstOrDefault()?.GetCustomAttributes(false).OfType<EnumMemberAttribute>().FirstOrDefault();
+            if (attr != null) return true;
+                return false;
+        }
+
+        /// <summary>
+        /// Get the EnumMember value
+        /// </summary>
+        /// <param name="enumVal"></param>
+        /// <returns>EnumMember value as string otherwise null</returns>
+        private static string GetEnumMemberAttrValue(object enumVal)
+        {
+            if (enumVal == null)
+                throw new ArgumentNullException(nameof(enumVal));
+            var enumType = enumVal.GetType();
+            var memInfo = enumType.GetMember(enumVal.ToString() ?? throw new InvalidOperationException());
+            var attr = memInfo.FirstOrDefault()?.GetCustomAttributes(false).OfType<EnumMemberAttribute>().FirstOrDefault();
+            if (attr != null)
+            {
+                return attr.Value;
+            }
+            return null;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/Configuration.cs b/src/Coscine.MetadataExtractor.Core/Client/Configuration.cs
similarity index 92%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/Configuration.cs
rename to src/Coscine.MetadataExtractor.Core/Client/Configuration.cs
index 5a8b348500da24ef95772f88c030019117e864c7..32eb3b6526f35dc676f5e10fd70423dc92388d98 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/Configuration.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/Configuration.cs
@@ -3,16 +3,24 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Net;
+using System.Reflection;
 using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Net.Http;
+using System.Net.Security;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Represents a set of configuration settings
@@ -50,6 +58,11 @@ namespace Org.OpenAPITools.Client
                     string.Format("Error calling {0}: {1}", methodName, response.RawContent),
                     response.RawContent, response.Headers);
             }
+            if (status == 0)
+            {
+                return new ApiException(status,
+                    string.Format("Error calling {0}: {1}", methodName, response.ErrorText), response.ErrorText);
+            }
             return null;
         };
 
@@ -63,6 +76,8 @@ namespace Org.OpenAPITools.Client
         /// </summary>
         private string _basePath;
 
+        private bool _useDefaultCredentials = false;
+
         /// <summary>
         /// Gets or sets the API key based on the authentication name.
         /// This is the key and value comprising the "secret" for accessing an API.
@@ -168,11 +183,21 @@ namespace Org.OpenAPITools.Client
         /// <summary>
         /// Gets or sets the base path for API access.
         /// </summary>
-        public virtual string BasePath {
+        public virtual string BasePath 
+        {
             get { return _basePath; }
             set { _basePath = value; }
         }
 
+        /// <summary>
+        /// Determine whether or not the "default credentials" (e.g. the user account under which the current process is running) will be sent along to the server. The default is false.
+        /// </summary>
+        public virtual bool UseDefaultCredentials
+        {
+            get { return _useDefaultCredentials; }
+            set { _useDefaultCredentials = value; }
+        }
+
         /// <summary>
         /// Gets or sets the default header.
         /// </summary>
@@ -437,7 +462,7 @@ namespace Org.OpenAPITools.Client
         /// <return>The operation server URL.</return>
         public string GetOperationServerUrl(string operation, int index, Dictionary<string, string> inputVariables)
         {
-            if (OperationServers.TryGetValue(operation, out var operationServer))
+            if (operation != null && OperationServers.TryGetValue(operation, out var operationServer))
             {
                 return GetServerUrl(operationServer, index, inputVariables);
             }
@@ -496,6 +521,11 @@ namespace Org.OpenAPITools.Client
 
             return url;
         }
+        
+        /// <summary>
+        /// Gets and Sets the RemoteCertificateValidationCallback
+        /// </summary>
+        public RemoteCertificateValidationCallback RemoteCertificateValidationCallback { get; set; }
 
         #endregion Properties
 
@@ -506,10 +536,10 @@ namespace Org.OpenAPITools.Client
         /// </summary>
         public static string ToDebugReport()
         {
-            string report = "C# SDK (Org.OpenAPITools) Debug Report:\n";
+            string report = "C# SDK (Coscine.MetadataExtractor.Core) Debug Report:\n";
             report += "    OS: " + System.Environment.OSVersion + "\n";
             report += "    .NET Framework Version: " + System.Environment.Version  + "\n";
-            report += "    Version of the API: 0.1.1\n";
+            report += "    Version of the API: 0.4.3\n";
             report += "    SDK Package Version: 1.0.0\n";
 
             return report;
@@ -572,6 +602,8 @@ namespace Org.OpenAPITools.Client
                 TempFolderPath = second.TempFolderPath ?? first.TempFolderPath,
                 DateTimeFormat = second.DateTimeFormat ?? first.DateTimeFormat,
                 ClientCertificates = second.ClientCertificates ?? first.ClientCertificates,
+                UseDefaultCredentials = second.UseDefaultCredentials,
+                RemoteCertificateValidationCallback = second.RemoteCertificateValidationCallback ?? first.RemoteCertificateValidationCallback,
             };
             return config;
         }
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ExceptionFactory.cs b/src/Coscine.MetadataExtractor.Core/Client/ExceptionFactory.cs
similarity index 81%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ExceptionFactory.cs
rename to src/Coscine.MetadataExtractor.Core/Client/ExceptionFactory.cs
index 0d5fda82167a736d9261c94647262e1725710af4..2a0a5de002d69b29d1a24a8a647b7aaffb424629 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ExceptionFactory.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/ExceptionFactory.cs
@@ -3,11 +3,14 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
-namespace Org.OpenAPITools.Client
+
+using System;
+
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// A delegate to ExceptionFactory method
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/GlobalConfiguration.cs b/src/Coscine.MetadataExtractor.Core/Client/GlobalConfiguration.cs
similarity index 93%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/GlobalConfiguration.cs
rename to src/Coscine.MetadataExtractor.Core/Client/GlobalConfiguration.cs
index 605aee5e073445cb2e1f7eadeafc54d2322c7cf5..8d186efef4711ccc002b1caaeaf0cfd89f7daea4 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/GlobalConfiguration.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/GlobalConfiguration.cs
@@ -3,11 +3,14 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
-namespace Org.OpenAPITools.Client
+
+using System.Collections.Generic;
+
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// <see cref="GlobalConfiguration"/> provides a compile-time extension point for globally configuring
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/HttpMethod.cs b/src/Coscine.MetadataExtractor.Core/Client/HttpMethod.cs
similarity index 88%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/HttpMethod.cs
rename to src/Coscine.MetadataExtractor.Core/Client/HttpMethod.cs
index fc1a07fd952bc8bc54e8d5e27fbd171ea1333093..4594e77bfdc5ae27e0decf361cc998250b30d992 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/HttpMethod.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/HttpMethod.cs
@@ -3,12 +3,12 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Http methods supported by swagger
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IApiAccessor.cs b/src/Coscine.MetadataExtractor.Core/Client/IApiAccessor.cs
similarity index 88%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IApiAccessor.cs
rename to src/Coscine.MetadataExtractor.Core/Client/IApiAccessor.cs
index 927831c5c5a951ecbe29972562f419e59c4f152f..5d9577f5ece99220d9853b6166dbd0c9d1a8f619 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IApiAccessor.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/IApiAccessor.cs
@@ -3,11 +3,14 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
-namespace Org.OpenAPITools.Client
+
+using System;
+
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Represents configuration aspects required to interact with the API endpoints.
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IAsynchronousClient.cs b/src/Coscine.MetadataExtractor.Core/Client/IAsynchronousClient.cs
similarity index 97%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IAsynchronousClient.cs
rename to src/Coscine.MetadataExtractor.Core/Client/IAsynchronousClient.cs
index 19cdcf1c5ec29f2919a3eb60d9f7255e1192a300..0cc5537b63fb4ae63823c3b54d5018edc1ffc180 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IAsynchronousClient.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/IAsynchronousClient.cs
@@ -3,11 +3,15 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
-namespace Org.OpenAPITools.Client
+
+using System;
+using System.Threading.Tasks;
+
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Contract for Asynchronous RESTful API interactions.
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IReadableConfiguration.cs b/src/Coscine.MetadataExtractor.Core/Client/IReadableConfiguration.cs
similarity index 82%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IReadableConfiguration.cs
rename to src/Coscine.MetadataExtractor.Core/Client/IReadableConfiguration.cs
index 99167b0135007010e69417eb4d7ff497287e915e..5a58d838948851aeebb7a611b8911be6aee0c3f1 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/IReadableConfiguration.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/IReadableConfiguration.cs
@@ -3,15 +3,18 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
+using System.Collections.Generic;
 using System.Net;
+using System.Net.Security;
 using System.Security.Cryptography.X509Certificates;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Represents a readable-only configuration contract.
@@ -97,6 +100,11 @@ namespace Org.OpenAPITools.Client
         /// <value>Password.</value>
         string Password { get; }
 
+        /// <summary>
+        /// Determine whether or not the "default credentials" (e.g. the user account under which the current process is running) will be sent along to the server. The default is false.
+        /// </summary>
+        bool UseDefaultCredentials { get; }
+
         /// <summary>
         /// Get the servers associated with the operation.
         /// </summary>
@@ -123,5 +131,11 @@ namespace Org.OpenAPITools.Client
         /// </summary>
         /// <value>X509 Certificate collection.</value>
         X509CertificateCollection ClientCertificates { get; }
+
+        /// <summary>
+        /// Callback function for handling the validation of remote certificates. Useful for certificate pinning and
+        /// overriding certificate errors in the scope of a request.
+        /// </summary>
+        RemoteCertificateValidationCallback RemoteCertificateValidationCallback { get; }
     }
 }
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ISynchronousClient.cs b/src/Coscine.MetadataExtractor.Core/Client/ISynchronousClient.cs
similarity index 97%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ISynchronousClient.cs
rename to src/Coscine.MetadataExtractor.Core/Client/ISynchronousClient.cs
index faa8a6cef607d0ab7c27f70e5c76e55b7c7ef33f..1fbc21870706c02dae81d744ad863107e7f89678 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/ISynchronousClient.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/ISynchronousClient.cs
@@ -3,11 +3,15 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
-namespace Org.OpenAPITools.Client
+
+using System;
+using System.IO;
+
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Contract for Synchronous RESTful API interactions.
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/Multimap.cs b/src/Coscine.MetadataExtractor.Core/Client/Multimap.cs
similarity index 98%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/Multimap.cs
rename to src/Coscine.MetadataExtractor.Core/Client/Multimap.cs
index 2c25243d9537df5db9b3675b4e2f96fa958ca7ee..f2b7cd437cb55f59fc318e00d6a644d718e40aff 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/Multimap.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/Multimap.cs
@@ -3,14 +3,16 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
 using System.Collections;
+using System.Collections.Generic;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// A dictionary in which one key has many associated values.
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/OpenAPIDateConverter.cs b/src/Coscine.MetadataExtractor.Core/Client/OpenAPIDateConverter.cs
similarity index 89%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/OpenAPIDateConverter.cs
rename to src/Coscine.MetadataExtractor.Core/Client/OpenAPIDateConverter.cs
index bc559a6e692b9449bba56f7449cf2cad37214614..bfeb936b1cea4bd60b8d7510e56bab8f09af0516 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/OpenAPIDateConverter.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/OpenAPIDateConverter.cs
@@ -3,13 +3,13 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 using Newtonsoft.Json.Converters;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Formatter for 'date' openapi formats ss defined by full-date - RFC3339
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/RequestOptions.cs b/src/Coscine.MetadataExtractor.Core/Client/RequestOptions.cs
similarity index 91%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/RequestOptions.cs
rename to src/Coscine.MetadataExtractor.Core/Client/RequestOptions.cs
index e4cdc9ac057acd8004a2c0330feca418953a6df5..c7a20a49cef09e6fb40d358caa107a93c1c3f3aa 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/RequestOptions.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/RequestOptions.cs
@@ -3,14 +3,17 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Net;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// A container for generalized request inputs. This type allows consumers to extend the request functionality
@@ -30,7 +33,7 @@ namespace Org.OpenAPITools.Client
         public Multimap<string, string> QueryParameters { get; set; }
 
         /// <summary>
-        /// Header parameters to be applied to to the request.
+        /// Header parameters to be applied to the request.
         /// Keys may have 1 or more values associated.
         /// </summary>
         public Multimap<string, string> HeaderParameters { get; set; }
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/RetryConfiguration.cs b/src/Coscine.MetadataExtractor.Core/Client/RetryConfiguration.cs
similarity index 87%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/RetryConfiguration.cs
rename to src/Coscine.MetadataExtractor.Core/Client/RetryConfiguration.cs
index a13875c9c7756b5f63349503eb04b6e6b0e484da..2c391a57f2c57c24f439d9bde547d9b678680a64 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Client/RetryConfiguration.cs
+++ b/src/Coscine.MetadataExtractor.Core/Client/RetryConfiguration.cs
@@ -3,7 +3,7 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
@@ -11,7 +11,7 @@
 using Polly;
 using RestSharp;
 
-namespace Org.OpenAPITools.Client
+namespace Coscine.MetadataExtractor.Core.Client
 {
     /// <summary>
     /// Configuration class to set the polly retry policies to be applied to the requests.
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Org.OpenAPITools.csproj b/src/Coscine.MetadataExtractor.Core/Coscine.MetadataExtractor.Core.csproj
similarity index 60%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Org.OpenAPITools.csproj
rename to src/Coscine.MetadataExtractor.Core/Coscine.MetadataExtractor.Core.csproj
index 5556b071837eddf2e7800b47e5fad66dbf540b84..5d84ca7908a183df7227f76302a97ba4a4934c45 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Org.OpenAPITools.csproj
+++ b/src/Coscine.MetadataExtractor.Core/Coscine.MetadataExtractor.Core.csproj
@@ -2,29 +2,29 @@
 
   <PropertyGroup>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo><!-- setting GenerateAssemblyInfo to false causes this bug https://github.com/dotnet/project-system/issues/3934 -->
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <AssemblyName>Org.OpenAPITools</AssemblyName>
-    <PackageId>Org.OpenAPITools</PackageId>
+    <TargetFramework>net7.0</TargetFramework>
+    <AssemblyName>Coscine.MetadataExtractor.Core</AssemblyName>
+    <PackageId>Coscine.MetadataExtractor.Core</PackageId>
     <OutputType>Library</OutputType>
     <Authors>OpenAPI</Authors>
     <Company>OpenAPI</Company>
     <AssemblyTitle>OpenAPI Library</AssemblyTitle>
     <Description>A library generated from a OpenAPI doc</Description>
     <Copyright>No Copyright</Copyright>
-    <RootNamespace>Org.OpenAPITools</RootNamespace>
-    <Version>0.1.10</Version>
-    <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\Org.OpenAPITools.xml</DocumentationFile>
+    <RootNamespace>Coscine.MetadataExtractor.Core</RootNamespace>
+    <Version>1.0.0</Version>
+    <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\Coscine.MetadataExtractor.Core.xml</DocumentationFile>
     <RepositoryUrl>https://github.com/GIT_USER_ID/GIT_REPO_ID.git</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageReleaseNotes>Minor update</PackageReleaseNotes>
+    <Nullable>annotations</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="JsonSubTypes" Version="1.9.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="RestSharp" Version="108.0.1" />
+    <PackageReference Include="JsonSubTypes" Version="2.0.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="RestSharp" Version="110.2.0" />
     <PackageReference Include="Polly" Version="7.2.3" />
-    <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/AbstractOpenAPISchema.cs b/src/Coscine.MetadataExtractor.Core/Model/AbstractOpenAPISchema.cs
similarity index 95%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/AbstractOpenAPISchema.cs
rename to src/Coscine.MetadataExtractor.Core/Model/AbstractOpenAPISchema.cs
index 3fe1ad38c50fe6dff4338d88d356d3a5dd3306f5..a24abdd2d50db7f3ac4a13988f22bfb16155fc0c 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/AbstractOpenAPISchema.cs
+++ b/src/Coscine.MetadataExtractor.Core/Model/AbstractOpenAPISchema.cs
@@ -3,15 +3,16 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
-namespace Org.OpenAPITools.Model
+namespace Coscine.MetadataExtractor.Core.Model
 {
     /// <summary>
     ///  Abstract base class for oneOf, anyOf schemas in the OpenAPI specification
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/MetadataOutput.cs b/src/Coscine.MetadataExtractor.Core/Model/MetadataOutput.cs
similarity index 89%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/MetadataOutput.cs
rename to src/Coscine.MetadataExtractor.Core/Model/MetadataOutput.cs
index 88e64127018216dc768684db4454287d747a8a28..a83b4a66bd50a0267b0826ccc47301e37e187642 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/MetadataOutput.cs
+++ b/src/Coscine.MetadataExtractor.Core/Model/MetadataOutput.cs
@@ -3,16 +3,27 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.IO;
 using System.Runtime.Serialization;
 using System.Text;
+using System.Text.RegularExpressions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
 using System.ComponentModel.DataAnnotations;
+using OpenAPIDateConverter = Coscine.MetadataExtractor.Core.Client.OpenAPIDateConverter;
 
-namespace Org.OpenAPITools.Model
+namespace Coscine.MetadataExtractor.Core.Model
 {
     /// <summary>
     /// MetadataOutput
@@ -144,7 +155,7 @@ namespace Org.OpenAPITools.Model
         /// </summary>
         /// <param name="validationContext">Validation context</param>
         /// <returns>Validation Result</returns>
-        public IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> Validate(ValidationContext validationContext)
+        IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
         {
             yield break;
         }
diff --git a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/ModelVersion.cs b/src/Coscine.MetadataExtractor.Core/Model/ModelVersion.cs
similarity index 69%
rename from src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/ModelVersion.cs
rename to src/Coscine.MetadataExtractor.Core/Model/ModelVersion.cs
index 9af8aa741dfbd60bfdd3d3788939f3a2218a6f20..8c116ef87bdffe298d8c577e6d522a081da4da15 100644
--- a/src/OpenApiGeneratedConnector/src/Org.OpenAPITools/Model/ModelVersion.cs
+++ b/src/Coscine.MetadataExtractor.Core/Model/ModelVersion.cs
@@ -3,37 +3,48 @@
  *
  * This API extracts RDF triples from files
  *
- * The version of the OpenAPI document: 0.1.1
+ * The version of the OpenAPI document: 0.4.3
  * Generated by: https://github.com/openapitools/openapi-generator.git
  */
 
 
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.IO;
 using System.Runtime.Serialization;
 using System.Text;
+using System.Text.RegularExpressions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Linq;
 using System.ComponentModel.DataAnnotations;
+using OpenAPIDateConverter = Coscine.MetadataExtractor.Core.Client.OpenAPIDateConverter;
 
-namespace Org.OpenAPITools.Model
+namespace Coscine.MetadataExtractor.Core.Model
 {
     /// <summary>
     /// ModelVersion
     /// </summary>
-    [DataContract(Name = "_Version")]
+    [DataContract(Name = "varVersion")]
     public partial class ModelVersion : IEquatable<ModelVersion>, IValidatableObject
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="ModelVersion" /> class.
         /// </summary>
-        /// <param name="version">version.</param>
-        public ModelVersion(string version = default(string))
+        /// <param name="varVersion">varVersion.</param>
+        public ModelVersion(string varVersion = default(string))
         {
-            this._Version = version;
+            this.VarVersion = varVersion;
         }
 
         /// <summary>
-        /// Gets or Sets _Version
+        /// Gets or Sets VarVersion
         /// </summary>
         [DataMember(Name = "version", EmitDefaultValue = false)]
-        public string _Version { get; set; }
+        public string VarVersion { get; set; }
 
         /// <summary>
         /// Returns the string presentation of the object
@@ -43,7 +54,7 @@ namespace Org.OpenAPITools.Model
         {
             StringBuilder sb = new StringBuilder();
             sb.Append("class ModelVersion {\n");
-            sb.Append("  _Version: ").Append(_Version).Append("\n");
+            sb.Append("  VarVersion: ").Append(VarVersion).Append("\n");
             sb.Append("}\n");
             return sb.ToString();
         }
@@ -80,9 +91,9 @@ namespace Org.OpenAPITools.Model
             }
             return 
                 (
-                    this._Version == input._Version ||
-                    (this._Version != null &&
-                    this._Version.Equals(input._Version))
+                    this.VarVersion == input.VarVersion ||
+                    (this.VarVersion != null &&
+                    this.VarVersion.Equals(input.VarVersion))
                 );
         }
 
@@ -95,9 +106,9 @@ namespace Org.OpenAPITools.Model
             unchecked // Overflow is fine, just wrap
             {
                 int hashCode = 41;
-                if (this._Version != null)
+                if (this.VarVersion != null)
                 {
-                    hashCode = (hashCode * 59) + this._Version.GetHashCode();
+                    hashCode = (hashCode * 59) + this.VarVersion.GetHashCode();
                 }
                 return hashCode;
             }
@@ -108,7 +119,7 @@ namespace Org.OpenAPITools.Model
         /// </summary>
         /// <param name="validationContext">Validation context</param>
         /// <returns>Validation Result</returns>
-        public IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> Validate(ValidationContext validationContext)
+        IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext)
         {
             yield break;
         }
diff --git a/src/MetadataExtractorCron.sln b/src/MetadataExtractorCron.sln
index 792e506fa06e77e39e9089a98c2afc3549f17829..a8aab1f51f580c07e7d249442f5c8e24f1468169 100644
--- a/src/MetadataExtractorCron.sln
+++ b/src/MetadataExtractorCron.sln
@@ -5,7 +5,7 @@ VisualStudioVersion = 17.1.32414.318
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MetadataExtractorCron", "MetadataExtractorCron\MetadataExtractorCron.csproj", "{B76A7422-1D0F-491F-B71C-D00E7C885C4A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenApiGeneratedConnector", "OpenApiGeneratedConnector\OpenApiGeneratedConnector.csproj", "{6FAAF00B-335B-4896-826F-06CA79CAA2E0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Coscine.MetadataExtractor.Core", "Coscine.MetadataExtractor.Core\Coscine.MetadataExtractor.Core.csproj", "{7260DEF1-77FC-4DEF-8EB4-9502B334DE6C}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -17,10 +17,10 @@ Global
 		{B76A7422-1D0F-491F-B71C-D00E7C885C4A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B76A7422-1D0F-491F-B71C-D00E7C885C4A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B76A7422-1D0F-491F-B71C-D00E7C885C4A}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6FAAF00B-335B-4896-826F-06CA79CAA2E0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6FAAF00B-335B-4896-826F-06CA79CAA2E0}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6FAAF00B-335B-4896-826F-06CA79CAA2E0}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6FAAF00B-335B-4896-826F-06CA79CAA2E0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7260DEF1-77FC-4DEF-8EB4-9502B334DE6C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7260DEF1-77FC-4DEF-8EB4-9502B334DE6C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7260DEF1-77FC-4DEF-8EB4-9502B334DE6C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7260DEF1-77FC-4DEF-8EB4-9502B334DE6C}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/src/MetadataExtractorCron/Extractors/CoscineMetadataExtractor.cs b/src/MetadataExtractorCron/Extractors/CoscineMetadataExtractor.cs
index 80a03f59dcbb5f8f33de9cf845134208c07be7a5..926169de7159008a90fac221776081eef32f6ac2 100644
--- a/src/MetadataExtractorCron/Extractors/CoscineMetadataExtractor.cs
+++ b/src/MetadataExtractorCron/Extractors/CoscineMetadataExtractor.cs
@@ -1,16 +1,17 @@
-using Coscine.Configuration;
-using Coscine.Database.Models;
-using Coscine.Metadata;
-using Coscine.ResourceTypes;
-using Coscine.ResourceTypes.Base;
-using Coscine.ResourceTypes.Base.Models;
-using Org.OpenAPITools.Api;
-using Org.OpenAPITools.Model;
-using VDS.RDF;
+using VDS.RDF;
 using MetadataExtractorCron.Util;
 using VDS.RDF.Parsing;
 using System.Globalization;
-using Coscine.Metadata.Util;
+using MetadataExtractorCron.Models.ConfigurationModels;
+using Coscine.ApiClient.Core.Model;
+using Coscine.ApiClient;
+using Coscine.ApiClient.Core.Api;
+using Coscine.ApiClient.Core.Client;
+using NLog;
+using MetadataExtractor.Util;
+using VDS.RDF.Writing;
+using Coscine.MetadataExtractor.Core.Model;
+using Coscine.MetadataExtractor.Core.Api;
 
 namespace MetadataExtractorCron.Extractors;
 
@@ -18,132 +19,135 @@ public class CoscineMetadataExtractor : IMetadataExtractor
 {
     private readonly string _resourceUrlPrefix = "https://purl.org/coscine/resources";
 
-    private readonly IConfiguration _configuration;
-    private readonly DefaultApi _apiClient;
+    private readonly MetadataExtractorConfiguration _metadataExtractorConfiguration;
 
-    private readonly RdfStoreConnector _rdfStoreConnector;
-    private readonly MetadataGraphsCreator _metadataGraphsCreator;
+    private readonly DefaultApi _extractionApiClient;
 
-    public CoscineMetadataExtractor()
+    private readonly string _adminToken;
+    protected readonly Configuration _apiConfiguration;
+    private readonly AdminApi _adminApi;
+    private readonly BlobApi _blobApi;
+    private readonly TreeApi _treeApi;
+
+    private readonly Logger _logger = LogManager.GetCurrentClassLogger();
+
+    public CoscineMetadataExtractor(MetadataExtractorConfiguration metadataExtractorConfiguration)
     {
-        _configuration = new ConsulConfiguration();
-        _apiClient = new DefaultApi(
-            _configuration.GetStringAndWait(
-                "coscine/local/metadataextractor/url",
-                "https://metadataextractor.otc.coscine.dev/"
-            )
-        );
-        _rdfStoreConnector = new RdfStoreConnector(_configuration.GetStringAndWait("coscine/local/virtuoso/additional/url"));
-        _metadataGraphsCreator = new MetadataGraphsCreator(_rdfStoreConnector);
+        _metadataExtractorConfiguration = metadataExtractorConfiguration;
+
+        _extractionApiClient = new DefaultApi(metadataExtractorConfiguration.MetadataExtractionUrl);
+
+        // Generate an admin token for the API Client
+        var jwtConfiguration = ApiConfigurationUtil.RetrieveJwtConfiguration();
+        _adminToken = ApiConfigurationUtil.GenerateAdminToken(jwtConfiguration);
+        _apiConfiguration = new Configuration()
+        {
+            BasePath = "http://localhost:7206/coscine",
+            ApiKeyPrefix = { { "Authorization", "Bearer" } },
+            ApiKey = { { "Authorization", _adminToken } },
+            Timeout = 300000, // 5 minutes
+        };
+        _adminApi = new AdminApi(_apiConfiguration);
+        _blobApi = new BlobApi(_apiConfiguration);
+        _treeApi = new TreeApi(_apiConfiguration);
     }
 
     public async Task PerformExtraction()
     {
-        var modelVersion = await _apiClient.GetVersionWorkerAsync();
-        var version = modelVersion._Version;
-
-        var metadataExtractionModel = new MetadataExtractionModel();
-        var resourceModel = new ResourceModel();
+        var resourcesAsyncList = PaginationHelper.GetAllAsync<ResourceAdminDtoPagedResponse, ResourceAdminDto>(
+            (currentPage) => _adminApi.GetAllResourcesAsync(includeDeleted: false, pageNumber: currentPage, pageSize: 50)
+        );
 
-        foreach (var extraction in metadataExtractionModel.GetAllWhere((extration) => extration.Activated))
+        await foreach (var resource in resourcesAsyncList)
         {
-            var resourceId = extraction.ResourceId;
-            Console.WriteLine($"Working on resource {resourceId}");
-            var resource = resourceModel.GetByIdIncludingDeleted(resourceId);
-
-            var resourceTypeDefinition = ResourceTypeFactory.Instance.GetResourceType(resource);
-            if (resourceTypeDefinition == null)
+            var projectId = resource.ProjectResources.FirstOrDefault()?.ProjectId;
+            if (!resource.MetadataExtraction || !projectId.HasValue)
             {
-                Console.WriteLine($"Broken resource type for resource {resourceId}");
                 continue;
             }
-            var resourceTypeOptions = resourceModel.GetResourceTypeOptions(resourceId);
+            string projectIdString = projectId.Value.ToString();
+
+            var resourceId = resource.Id;
+
+            _logger.Info($"Working on resource {resourceId}");
 
-            var fileInfos = await ReceiveAllFiles(resourceTypeDefinition, resourceId.ToString(), resourceTypeOptions);
+            var fileInfos = await ReceiveAllFiles(projectIdString, resourceId);
 
-            foreach (var file in fileInfos.Where((fileInfo) => fileInfo.HasBody))
+            foreach (var file in fileInfos.Where((fileInfo) => fileInfo.Type == TreeDataType.Leaf))
             {
-                if (file.BodyBytes > VersionUtil.DetectionByteLimit)
+                if (file.Size > _metadataExtractorConfiguration.DetectionByteLimit)
                 {
-                    Console.WriteLine($"Skipping {file.Key} on {resourceId} since it has a too large byte size");
+                    _logger.Info($"Skipping {file.Path} on {resourceId} since it has a too large byte size");
                     continue;
                 }
-                Console.WriteLine($"Iterating over {file.Key} on {resourceId}");
-                CreateMetadataSetsIfDontExist(resourceId.ToString(), file);
-                if (!HasCurrentMetadataExtracted(resourceId.ToString(), file))
+                _logger.Info($"Iterating over {file.Path} on {resourceId}");
+                if (!await HasCurrentMetadataExtracted(projectIdString, resourceId, file))
                 {
-                    Console.WriteLine($"Extracting metadata for {file.Key} on {resourceId}");
+                    _logger.Info($"Extracting metadata for {file.Path} on {resourceId}");
                     try
                     {
-                        var extractedMetadata = await ExtractMetadata(resourceId.ToString(), file, resourceTypeDefinition, resourceTypeOptions);
-                        await StoreExtractedMetadata(resourceId.ToString(), file, extractedMetadata, resourceTypeDefinition, resourceTypeOptions);
+                        var extractedMetadata = await ExtractMetadata(projectIdString, resourceId, file);
+                        await StoreExtractedMetadata(projectIdString, resourceId, file, extractedMetadata);
                     }
                     catch (Exception e)
                     {
-                        Console.WriteLine($"Error extracting metadata for {file.Key} on {resourceId} with error message: {e.Message}, Inner: {(e.InnerException != null ? e.InnerException.Message : "none")}");
+                        _logger.Info($"Error extracting metadata for {file.Path} on {resourceId} with error message: {e.Message}, Inner: {(e.InnerException != null ? e.InnerException.Message : "none")}");
                     }
                 }
                 else
                 {
-                    Console.WriteLine($"Metadata for {file.Key} on {resourceId} already exists");
+                    _logger.Info($"Metadata for {file.Path} on {resourceId} already exists");
                 }
             }
         }
     }
 
-    private async Task<IEnumerable<ResourceEntry>> ReceiveAllFiles(BaseResourceType resourceTypeDefinition, string resourceId, Dictionary<string, string>? resourceTypeOptions, string path = "")
+    private async Task<IEnumerable<FileTreeDto>> ReceiveAllFiles(string projectId, Guid resourceId, string path = "")
     {
-        var fileInfos = new List<ResourceEntry>();
-        var currentFileInfos = await resourceTypeDefinition.ListEntries(resourceId, path, resourceTypeOptions);
+        var fileInfos = new List<FileTreeDto>();
+
+        var currentFileInfos = await PaginationHelper.GetAll<FileTreeDtoPagedResponse, FileTreeDto>(
+            (currentPage) => _treeApi.GetFileTreeAsync(projectId, resourceId, path, pageNumber: currentPage, pageSize: 50)
+        );
         fileInfos.AddRange(currentFileInfos);
-        foreach (var currentFileInfo in currentFileInfos.Where((currentFileInfo) => !currentFileInfo.HasBody))
+        foreach (var currentFileInfo in currentFileInfos.Where(
+            (currentFileInfo) => currentFileInfo.Type == TreeDataType.Tree
+                // Deal with things like the ".coscine" folder
+                && currentFileInfo.Hidden == false
+        ))
         {
-            fileInfos.AddRange(await ReceiveAllFiles(resourceTypeDefinition, resourceId, resourceTypeOptions, currentFileInfo.Key));
+            fileInfos.AddRange(await ReceiveAllFiles(projectId, resourceId, currentFileInfo.Path));
         }
         return fileInfos;
     }
 
-    private void CreateMetadataSetsIfDontExist(string resourceId, ResourceEntry entry)
+    private async Task<bool> HasCurrentMetadataExtracted(string projectId, Guid resourceId, FileTreeDto entry)
     {
-        var existingGraphs = _rdfStoreConnector.GetMetadataIds(resourceId, entry.Key);
-        if (!existingGraphs.Any())
+        var metadataTreeResponse = await _treeApi.GetSpecificMetadataTreeAsync(projectId, resourceId, entry.Path, includeExtractedMetadata: true);
+        if (
+            metadataTreeResponse is not null
+            && metadataTreeResponse.Data.AvailableVersions.Count != 0
+            && metadataTreeResponse.Data.Extracted is not null
+            && metadataTreeResponse.Data.Extracted.Definition is not null
+        )
         {
-            Console.WriteLine($"Creating graphs for {resourceId}, {entry.Key} since they did not exist before!");
-            GraphStorer.StoreGraphs(_metadataGraphsCreator.CreateGraphs(
-                resourceId,
-                entry.Key,
-                true,
-                true
-            ), _rdfStoreConnector);
+            var version = VersionUtil.GetVersion(metadataTreeResponse.Data.Extracted.MetadataId) + "";
+            if (version == metadataTreeResponse.Data.VarVersion)
+            {
+                return true;
+            }
         }
-    }
 
-    private bool HasCurrentMetadataExtracted(string resourceId, ResourceEntry entry)
-    {
-        var existingGraphs = _rdfStoreConnector.GetDataIds(resourceId, entry.Key);
-        var existingExtractedGraphs = _rdfStoreConnector.GetDataIds(resourceId, entry.Key, true);
-        var recentDataVersion = VersionUtil.GetRecentDataVersion(existingGraphs);
-        var recentDataExtractedVersion = VersionUtil.GetRecentDataExtractedVersion(existingExtractedGraphs);
-
-        return
-            recentDataExtractedVersion != null
-            && recentDataVersion != null
-            && recentDataExtractedVersion.Contains(recentDataVersion)
-            && recentDataExtractedVersion != recentDataVersion;
+        return false;
     }
 
-    private async Task<MetadataOutput> ExtractMetadata(string resourceId, ResourceEntry entry, BaseResourceType resourceTypeDefinition, Dictionary<string, string>? resourceTypeOptions)
+    private async Task<MetadataOutput> ExtractMetadata(string projectId, Guid resourceId, FileTreeDto entry)
     {
-        var loadedEntry = await resourceTypeDefinition.LoadEntry(resourceId, entry.Key, resourceTypeOptions);
-
-        if (loadedEntry is null)
-        {
-            throw new NullReferenceException("The resulting stream of the loaded entry is null.");
-        }
+        var loadedEntry = await _blobApi.GetBlobAsync(projectId, resourceId, entry.Path)
+            ?? throw new NullReferenceException("The resulting stream of the loaded entry is null.");
 
-        var tempFile = Path.Combine(Path.GetTempPath(), Path.GetFileName(entry.Key));
-
-        using (var fs = new FileStream(tempFile, FileMode.CreateNew, FileAccess.Write))
+        var tempFile = Path.Combine(Path.GetTempPath(), Path.GetFileName(entry.Path));
+        using (var fs = new FileStream(tempFile, FileMode.Create, FileAccess.Write))
         {
             loadedEntry.CopyTo(fs);
         }
@@ -151,12 +155,12 @@ public class CoscineMetadataExtractor : IMetadataExtractor
         var givenStream = File.OpenRead(tempFile);
         try
         {
-            var extractedOutputs = await _apiClient.PostMetadataExtractorWorkerAsync(
-                givenStream,
-                $"{resourceId}/{entry.Key.Replace("\\", "/")}",
-                null!,
-                entry.Created?.ToString("o", CultureInfo.InvariantCulture)!,
-                entry.Modified?.ToString("o", CultureInfo.InvariantCulture)!
+            var extractedOutputs = await _extractionApiClient.PostMetadataExtractorWorkerAsync(
+                "application/json",
+                identifier: $"{resourceId}/{entry.Path.Replace("\\", "/")}",
+                creationDate: entry.CreationDate?.ToString("o", CultureInfo.InvariantCulture)!,
+                modificationDate: entry.ChangeDate?.ToString("o", CultureInfo.InvariantCulture)!,
+                file: givenStream
             );
 
             return extractedOutputs[0];
@@ -168,108 +172,126 @@ public class CoscineMetadataExtractor : IMetadataExtractor
         }
     }
 
-    private async Task StoreExtractedMetadata(string resourceId, ResourceEntry entry, MetadataOutput extractedMetadata, BaseResourceType resourceTypeDefinition, Dictionary<string, string>? resourceTypeOptions)
+    private async Task StoreExtractedMetadata(string projectId, Guid resourceId, FileTreeDto entry, MetadataOutput extractedMetadata)
     {
-        var metadataExtractorVersion = (await _apiClient.GetVersionWorkerAsync())._Version;
+        var metadataExtractorVersion = (await _extractionApiClient.GetVersionWorkerAsync()).VarVersion;
 
         var resourceGraphName = $"{_resourceUrlPrefix}/{resourceId}";
-        var newFileGraphName = $"{resourceGraphName}/{entry.Key}";
+        var newFileGraphName = $"{resourceGraphName}/{entry.Path}";
         var newFileGraphNameAddon = newFileGraphName;
-        if (!newFileGraphNameAddon.EndsWith("/"))
+        if (!newFileGraphNameAddon.EndsWith('/'))
         {
             newFileGraphNameAddon += "/";
         }
 
-        var recentDataVersion = _rdfStoreConnector.GetDataId(resourceId, entry.Key);
-        var recentMetadataVersion = _rdfStoreConnector.GetMetadataId(resourceId, entry.Key);
+        var metadataTreeResponse = await _treeApi.GetSpecificMetadataTreeAsync(projectId, resourceId, entry.Path);
 
-        await CreateHashData(resourceId, entry, resourceTypeDefinition, resourceTypeOptions, newFileGraphNameAddon, recentDataVersion);
+        var recentMetadataVersion = metadataTreeResponse?.Data.Id;
+        var recentDataVersion = recentMetadataVersion?.Replace("type=metadata", "type=data");
 
-        if (recentDataVersion is null)
-        {
-            throw new NullReferenceException("The recent data version is null and can't be used.");
-        }
+        var possibleNewVersion = VersionUtil.GetNewVersion();
+        var possibleNewDataVersion = $"{newFileGraphNameAddon}@type=data&version={possibleNewVersion}";
+        var possibleNewMetadataVersion = $"{newFileGraphNameAddon}@type=metadata&version={possibleNewVersion}";
 
-        var recentDataExtractedVersion = new Uri(recentDataVersion + "&extracted=true");
+        var hashValue = await CreateHashData(projectId, resourceId, entry);
 
-        if (recentMetadataVersion is null)
-        {
-            throw new NullReferenceException("The recent metadata version is null and can't be used.");
-        }
+        var correctMetadataVersion = (recentMetadataVersion ?? possibleNewMetadataVersion);
 
-        var recentMetadataExtractedVersion = new Uri(recentMetadataVersion + "&extracted=true");
+        var recentDataExtractedVersion = new Uri((recentDataVersion ?? possibleNewDataVersion) + "&extracted=true");
+        var recentMetadataExtractedVersion = new Uri(correctMetadataVersion + "&extracted=true");
 
         var tripleStore = new TripleStore();
-        tripleStore.LoadFromString(extractedMetadata.Metadata, new TriGParser(TriGSyntax.Recommendation));
-
-        FormatResultMetadata(tripleStore, recentDataExtractedVersion, recentMetadataExtractedVersion);
-
-        GraphStorer.StoreGraphs(tripleStore.Graphs, _rdfStoreConnector);
+        tripleStore.LoadFromString(extractedMetadata.Metadata, new TriGParser(TriGSyntax.Rdf11));
 
-        GraphStorer.StoreGraphs(
-            _metadataGraphsCreator.UpdateExtractionGraphs(
-                resourceId,
-                entry.Key,
-                recentDataVersion,
-                recentMetadataVersion,
-                metadataExtractorVersion
-            ),
-        _rdfStoreConnector);
-    }
+        var trigWriter = new TriGWriter();
 
-    private async Task CreateHashData(string resourceId, ResourceEntry entry, BaseResourceType resourceTypeDefinition, Dictionary<string, string>? resourceTypeOptions, string newFileGraphNameAddon, string? recentDataVersion)
-    {
-        var dataGraphName = $"{newFileGraphNameAddon}@type=data";
-        var dataGraph = CreateOrGetGraph(dataGraphName);
-
-        var loadedEntry = await resourceTypeDefinition.LoadEntry(resourceId, entry.Key, resourceTypeOptions);
+        FormatResultMetadata(tripleStore, recentDataExtractedVersion, recentMetadataExtractedVersion);
 
-        if (loadedEntry is null)
+        if (recentMetadataVersion is null)
         {
-            throw new NullReferenceException("The resulting stream of the loaded entry is null, when trying to hash the data.");
+            await _treeApi.CreateExtractedMetadataTreeAsync(
+                projectId,
+                resourceId,
+                new ExtractedMetadataTreeForCreationDto(
+                    path: entry.Path,
+                    id: correctMetadataVersion,
+                    definition: new RdfDefinitionForManipulationDto(
+                        VDS.RDF.Writing.StringWriter.Write(tripleStore, trigWriter),
+                        RdfFormat.ApplicationXTrig
+                    ),
+                    provenance: new ProvenanceParametersDto(
+                        metadataExtractorVersion: metadataExtractorVersion,
+                        hashParameters: new HashParametersDto(
+                            HashUtil.DefaultHashAlgorithm.Name ?? "SHA512",
+                            hashValue
+                        )
+                    )
+                )
+            );
         }
-
-        var defaultHash = Convert.ToBase64String(HashUtil.HashData(loadedEntry));
-
-        if (recentDataVersion is null)
+        else
         {
-            return;
+            await _treeApi.UpdateExtractedMetadataTreeAsync(
+                projectId,
+                resourceId,
+                new ExtractedMetadataTreeForUpdateDto(
+                    path: entry.Path,
+                    id: correctMetadataVersion,
+                    definition: new RdfDefinitionForManipulationDto(
+                        VDS.RDF.Writing.StringWriter.Write(tripleStore, trigWriter),
+                        RdfFormat.ApplicationXTrig
+                    ),
+                    provenance: new ProvenanceParametersDto(
+                        metadataExtractorVersion: metadataExtractorVersion,
+                        hashParameters: new HashParametersDto(
+                            HashUtil.DefaultHashAlgorithm.Name ?? "SHA512",
+                            hashValue
+                        )
+                    )
+                )
+            );
         }
+    }
+
+    private async Task<string> CreateHashData(string projectId, Guid resourceId, FileTreeDto entry)
+    {
+        var loadedEntry = await _blobApi.GetBlobAsync(projectId, resourceId, entry.Path)
+            ?? throw new NullReferenceException("The resulting stream of the loaded entry is null, when trying to hash the data.");
 
-        GraphStorer.AddToGraph(dataGraph, HashUtil.CreateHashTriples(
-            dataGraph, new Uri(recentDataVersion), defaultHash
-        ), _rdfStoreConnector);
+        return Convert.ToBase64String(HashUtil.HashData(loadedEntry));
     }
 
     private static void FormatResultMetadata(TripleStore tripleStore, Uri dataExtractGraph, Uri metadataExtractGraph)
     {
         foreach (var graph in tripleStore.Graphs.ToArray())
         {
-            if (graph.BaseUri != dataExtractGraph && graph.BaseUri != metadataExtractGraph)
+            if (graph.Name is IUriNode)
             {
-                tripleStore.Remove(graph.BaseUri);
-                if (graph.BaseUri.AbsoluteUri.Contains("type=data"))
+                var graphName = (IUriNode)graph.Name;
+                if (graphName.Uri.AbsoluteUri != dataExtractGraph.AbsoluteUri && graphName.Uri.AbsoluteUri != metadataExtractGraph.AbsoluteUri)
                 {
-                    graph.BaseUri = dataExtractGraph;
-                }
-                else
-                {
-                    graph.BaseUri = metadataExtractGraph;
+                    tripleStore.Remove(graph.Name);
+                    if (graphName.Uri.AbsoluteUri.Contains("type=data"))
+                    {
+                        var newGraph = new Graph(dataExtractGraph)
+                        {
+                            BaseUri = dataExtractGraph
+                        };
+                        newGraph.Assert(graph.Triples);
+                        tripleStore.Add(newGraph, true);
+                    }
+                    else
+                    {
+                        var newGraph = new Graph(metadataExtractGraph)
+                        {
+                            BaseUri = metadataExtractGraph
+                        };
+                        newGraph.Assert(graph.Triples);
+                        tripleStore.Add(newGraph, true);
+                    }
                 }
-                tripleStore.Add(graph, true);
             }
         }
     }
 
-    private IGraph CreateOrGetGraph(string graphUrl)
-    {
-        var entryAlreadyExists = _rdfStoreConnector.HasGraph(graphUrl);
-        return entryAlreadyExists
-            ? _rdfStoreConnector.GetGraph(graphUrl)
-            : new Graph()
-            {
-                BaseUri = new Uri(graphUrl)
-            };
-    }
-
 }
\ No newline at end of file
diff --git a/src/MetadataExtractorCron/MetadataExtractorCron.csproj b/src/MetadataExtractorCron/MetadataExtractorCron.csproj
index 0c9a9debf48124298a2f02c2faf5381ee024429a..7377e811615e2bc05c5a5f13f658be64be0a0ffc 100644
--- a/src/MetadataExtractorCron/MetadataExtractorCron.csproj
+++ b/src/MetadataExtractorCron/MetadataExtractorCron.csproj
@@ -1,21 +1,26 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   <Version>0.1.10</Version></PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Coscine.Database" Version="*-*" />
-    <PackageReference Include="Coscine.Metadata" Version="2.9.0" />
-    <PackageReference Include="Coscine.ResourceTypes" Version="*-*" />
-    <PackageReference Include="dotNetRDF" Version="2.7.5" />
+    <PackageReference Include="Coscine.ApiClient" Version="1.8.0-issue-2769-migra0018" />
+    <PackageReference Include="dotNetRDF" Version="3.1.1" />
+    <PackageReference Include="NLog" Version="5.2.8" />
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\OpenApiGeneratedConnector\OpenApiGeneratedConnector.csproj" />
+    <ProjectReference Include="..\Coscine.MetadataExtractor.Core\Coscine.MetadataExtractor.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="nlog.config">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 
 </Project>
diff --git a/src/MetadataExtractorCron/Models/ConfigurationModels/MetadataExtractorConfiguration.cs b/src/MetadataExtractorCron/Models/ConfigurationModels/MetadataExtractorConfiguration.cs
new file mode 100644
index 0000000000000000000000000000000000000000..1eeaaadc640e91267a4e72a82aa76f768cf8efe4
--- /dev/null
+++ b/src/MetadataExtractorCron/Models/ConfigurationModels/MetadataExtractorConfiguration.cs
@@ -0,0 +1,40 @@
+namespace MetadataExtractorCron.Models.ConfigurationModels;
+
+/// <summary>
+/// Represents the configuration settings used in the application.
+/// </summary>
+public class MetadataExtractorConfiguration
+{
+    /// <summary>
+    /// The section name in the configuration file.
+    /// </summary>
+    public static readonly string Section = "MetadataExtractorConfiguration";
+
+    /// <summary>
+    /// Value indicating whether Metadata Extraction is enabled.
+    /// </summary>
+    public bool IsEnabled { get; init; } = true;
+
+    /// <summary>
+    /// Url of the metadata extraction service.
+    /// </summary>
+    public string MetadataExtractionUrl { get; init; } = "https://metadataextractor.otc.coscine.dev/";
+
+    /// <summary>
+    /// The maximum file size for research data which should be analyzed by e.g. Metadata Extractor or Tracker
+    /// </summary>
+    public long DetectionByteLimit { get; init; } = 16 * 1000 * 1000L;
+
+    /// <summary>
+    /// Logger configuration settings.
+    /// </summary>
+    /// <value>
+    /// The logger storage configuration settings, or <c>null</c> if not configured.
+    /// </value>
+    public LoggerConfiguration? Logger { get; init; }
+
+    /// <summary>
+    /// Represents the configuration settings for the logger.
+    /// </summary>
+    public record LoggerConfiguration(string? LogLevel, string? LogHome);
+}
diff --git a/src/MetadataExtractorCron/Program.cs b/src/MetadataExtractorCron/Program.cs
index 7913c0f2f241156ab1e76b62a1d75cd4457b19a3..22f145b2e27b60ab8af2b2fed6729dcfd4a99689 100644
--- a/src/MetadataExtractorCron/Program.cs
+++ b/src/MetadataExtractorCron/Program.cs
@@ -1,7 +1,56 @@
 using MetadataExtractorCron.Extractors;
+using MetadataExtractorCron.Models.ConfigurationModels;
+using Microsoft.Extensions.Configuration;
+using NLog;
+using Winton.Extensions.Configuration.Consul;
 
-var metadataExtractor = new CoscineMetadataExtractor();
+var configBuilder = new ConfigurationBuilder();
 
-await metadataExtractor.PerformExtraction();
+var consulUrl = Environment.GetEnvironmentVariable("CONSUL_URL") ?? "http://localhost:8500";
 
-Console.WriteLine("Finished.");
\ No newline at end of file
+var configuration = configBuilder
+    .AddConsul(
+        "coscine/Coscine.Infrastructure/MetadataExtractorCron/appsettings",
+        options =>
+        {
+            options.ConsulConfigurationOptions =
+                cco => cco.Address = new Uri(consulUrl);
+            options.Optional = true;
+            options.ReloadOnChange = true;
+            options.PollWaitTime = TimeSpan.FromSeconds(5);
+            options.OnLoadException = exceptionContext => exceptionContext.Ignore = true;
+        }
+    )
+    .AddEnvironmentVariables()
+    .Build();
+
+var metadataExtractorConfiguration = new MetadataExtractorConfiguration();
+configuration.Bind(MetadataExtractorConfiguration.Section, metadataExtractorConfiguration);
+
+// Set the default LogLevel
+LogManager.Configuration.Variables["logLevel"] = metadataExtractorConfiguration.Logger?.LogLevel ?? "Trace";
+// Set the log location
+LogManager.Configuration.Variables["logHome"] = metadataExtractorConfiguration.Logger?.LogHome ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Logs");
+
+var logger = LogManager.GetCurrentClassLogger();
+
+if (!metadataExtractorConfiguration.IsEnabled)
+{
+    logger.Info("Disabled, skipped run.");
+    return;
+}
+
+try
+{
+    var metadataExtractor = new CoscineMetadataExtractor(metadataExtractorConfiguration);
+
+    await metadataExtractor.PerformExtraction();
+}
+catch (Exception e)
+{
+    logger.Info("Aborted on error.");
+    logger.Error(e);
+    return;
+}
+
+logger.Info("Finished successfully.");
diff --git a/src/MetadataExtractorCron/Util/GraphStorer.cs b/src/MetadataExtractorCron/Util/GraphStorer.cs
deleted file mode 100644
index 3e46ba84d1ac7d924851e0ca9d70fbb75289069e..0000000000000000000000000000000000000000
--- a/src/MetadataExtractorCron/Util/GraphStorer.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using Coscine.Metadata;
-using VDS.RDF;
-
-namespace MetadataExtractorCron.Util;
-
-public static class GraphStorer
-{
-    public static void StoreGraphs(IEnumerable<IGraph> graphUris, RdfStoreConnector rdfStoreConnector)
-    {
-        foreach (var graphUri in graphUris)
-        {
-            rdfStoreConnector.AddGraph(graphUri);
-        }
-    }
-
-    public static void AddToGraph(IGraph graph, IEnumerable<Triple> triples, RdfStoreConnector rdfStoreConnector)
-    {
-        Console.WriteLine($" - Adding Triples to {graph.BaseUri}");
-        rdfStoreConnector.AddToGraph(graph, triples);
-        Console.WriteLine($" - Triples added to Graph {graph.BaseUri} successfully");
-        Console.WriteLine();
-    }
-}
\ No newline at end of file
diff --git a/src/MetadataExtractorCron/Util/HashUtil.cs b/src/MetadataExtractorCron/Util/HashUtil.cs
new file mode 100644
index 0000000000000000000000000000000000000000..dcdcf4fb0caf767e07e22c2bfdf36d038133a3af
--- /dev/null
+++ b/src/MetadataExtractorCron/Util/HashUtil.cs
@@ -0,0 +1,45 @@
+using System.Security.Cryptography;
+
+namespace MetadataExtractorCron.Util
+{
+    /// <summary>
+    /// Provides utility functions to calculate hashes of research data
+    /// </summary>
+    public static class HashUtil
+    {
+        /// <summary>
+        /// The default hash algorithm being used (SHA512)
+        /// </summary>
+        public static HashAlgorithmName DefaultHashAlgorithm => HashAlgorithmName.SHA512;
+
+        private static HashAlgorithm GetHashAlgorithm(HashAlgorithmName hashAlgorithmName)
+        {
+            if (hashAlgorithmName == HashAlgorithmName.MD5)
+                return MD5.Create();
+            if (hashAlgorithmName == HashAlgorithmName.SHA1)
+                return SHA1.Create();
+            if (hashAlgorithmName == HashAlgorithmName.SHA256)
+                return SHA256.Create();
+            if (hashAlgorithmName == HashAlgorithmName.SHA384)
+                return SHA384.Create();
+            if (hashAlgorithmName == HashAlgorithmName.SHA512)
+                return SHA512.Create();
+
+            throw new CryptographicException($"Unknown hash algorithm \"{hashAlgorithmName.Name}\".");
+        }
+
+        /// <summary>
+        /// Takes a data stream and returns a hash represnetation of it
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="hashAlgorithmName"></param>
+        /// <returns></returns>
+        public static byte[] HashData(Stream data, HashAlgorithmName? hashAlgorithmName = null)
+        {
+            hashAlgorithmName ??= DefaultHashAlgorithm;
+            using var hashAlgorithmObject = GetHashAlgorithm(hashAlgorithmName.Value);
+            return hashAlgorithmObject.ComputeHash(data);
+        }
+    }
+}
+
diff --git a/src/MetadataExtractorCron/Util/VersionUtil.cs b/src/MetadataExtractorCron/Util/VersionUtil.cs
new file mode 100644
index 0000000000000000000000000000000000000000..07017d822b380137b2a05d8d0fbbd27af3dba803
--- /dev/null
+++ b/src/MetadataExtractorCron/Util/VersionUtil.cs
@@ -0,0 +1,198 @@
+namespace MetadataExtractor.Util
+{
+    /// <summary>
+    /// Utility for determining versions
+    /// </summary>
+    public static class VersionUtil
+    {
+        /// <summary>
+        /// Receives the recent version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <param name="filter"></param>
+        /// <param name="notFilterExtracted"></param>
+        /// <returns></returns>
+        public static Uri? GetRecentVersion(IEnumerable<Uri>? graphs, string? filter = null, bool notFilterExtracted = true)
+        {
+            if (graphs is null)
+            {
+                return null;
+            }
+            var recentVersion = GetRecentVersion(graphs.Select((graph) => graph.AbsoluteUri), filter, notFilterExtracted);
+            if (recentVersion is not null)
+            {
+                return new Uri(recentVersion);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Receives the recent version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <param name="filter"></param>
+        /// <param name="notFilterExtracted"></param>
+        /// <returns></returns>
+        public static string? GetRecentVersion(IEnumerable<string>? graphs, string? filter = null, bool notFilterExtracted = true)
+        {
+            if (graphs is null)
+            {
+                return null;
+            }
+            string? currentBest = null;
+            var currentBestVersion = -1L;
+            foreach (var graph in graphs)
+            {
+                var queryDictionary = System.Web.HttpUtility.ParseQueryString(
+                    new Uri(graph.Replace("@", "?")).Query);
+                var version = queryDictionary["version"];
+                if (version is null || !long.TryParse(version, out long longVersion))
+                {
+                    continue;
+                }
+                if (longVersion > currentBestVersion
+                    && (filter is null || queryDictionary["type"] == filter)
+                    && ((notFilterExtracted && queryDictionary["extracted"] is null)
+                        || (!notFilterExtracted && queryDictionary["extracted"] is not null))
+                )
+                {
+                    currentBestVersion = longVersion;
+                    currentBest = graph;
+                }
+            }
+            return currentBest;
+        }
+
+        /// <summary>
+        /// Receives the recent data version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static Uri? GetRecentDataVersion(IEnumerable<Uri>? graphs)
+        {
+            return GetRecentVersion(graphs, "data");
+        }
+
+        /// <summary>
+        /// Receives the recent data version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static string? GetRecentDataVersion(IEnumerable<string>? graphs)
+        {
+            return GetRecentVersion(graphs, "data");
+        }
+
+        /// <summary>
+        /// Receives the recent extracted data version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static Uri? GetRecentDataExtractedVersion(IEnumerable<Uri> graphs)
+        {
+            return GetRecentVersion(graphs, "data", false);
+        }
+
+        /// <summary>
+        /// Receives the recent extracted data version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static string? GetRecentDataExtractedVersion(IEnumerable<string> graphs)
+        {
+            return GetRecentVersion(graphs, "data", false);
+        }
+
+        /// <summary>
+        /// Receives the recent metadata version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static Uri? GetRecentMetadataVersion(IEnumerable<Uri>? graphs)
+        {
+            return GetRecentVersion(graphs, "metadata");
+        }
+
+        /// <summary>
+        /// Receives the recent metadata version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static string? GetRecentMetadataVersion(IEnumerable<string>? graphs)
+        {
+            return GetRecentVersion(graphs, "metadata");
+        }
+
+        /// <summary>
+        /// Receives the recent extracted metadata version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static Uri? GetRecentMetadataExtractedVersion(IEnumerable<Uri>? graphs)
+        {
+            return GetRecentVersion(graphs, "metadata", false);
+        }
+
+        /// <summary>
+        /// Receives the recent extracted metadata version by the given parameters
+        /// </summary>
+        /// <param name="graphs"></param>
+        /// <returns></returns>
+        public static string? GetRecentMetadataExtractedVersion(IEnumerable<string>? graphs)
+        {
+            return GetRecentVersion(graphs, "metadata", false);
+        }
+
+        /// <summary>
+        /// Creates a new version with the current timestamp
+        /// </summary>
+        /// <returns></returns>
+        public static long GetNewVersion()
+        {
+            // UTC Timestamp
+            return CalculateVersion(DateTime.UtcNow);
+        }
+
+        /// <summary>
+        /// Calculates a new version based on the given timestamp
+        /// </summary>
+        /// <param name="dateTime"></param>
+        /// <returns></returns>
+        public static long CalculateVersion(DateTime dateTime)
+        {
+            return long.Parse(Convert.ToString((int)dateTime.Subtract(new DateTime(1970, 1, 1)).TotalSeconds));
+        }
+
+        /// <summary>
+        /// Gets the version from the given graphUri
+        /// </summary>
+        /// <param name="graphUri">string representation of the given graph uri</param>
+        /// <returns></returns>
+        public static long? GetVersion(string? graphUri)
+        {
+            if (graphUri is null)
+            {
+                return null;
+            }
+            var queryDictionary = System.Web.HttpUtility.ParseQueryString(
+                new Uri(graphUri.Replace("@", "?")).Query);
+            var version = queryDictionary["version"];
+            var couldParse = long.TryParse(version, out long longVersion);
+            return couldParse ? longVersion : null;
+        }
+
+        /// <summary>
+        /// Gets the version from the given graphUri
+        /// </summary>
+        /// <param name="graphUri"></param>
+        /// <returns></returns>
+        public static long? GetVersion(Uri? graphUri)
+        {
+            if (graphUri is null)
+            {
+                return null;
+            }
+            return GetVersion(graphUri.AbsoluteUri);
+        }
+    }
+}
diff --git a/src/MetadataExtractorCron/nlog.config b/src/MetadataExtractorCron/nlog.config
new file mode 100644
index 0000000000000000000000000000000000000000..c2fd7e323b320dadeb7946287dedab42a29a9c82
--- /dev/null
+++ b/src/MetadataExtractorCron/nlog.config
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        autoReload="true"
+        internalLogLevel="Warn"
+        internalLogFile=".\internal_logs\internallog.txt">
+
+	<variable name="logHome" value="${basedir}/Logs" />
+	<variable name="logLevel" value="Warn" />
+
+	<!--Possible aspnet- variables: https://nlog-project.org/config/?tab=layout-renderers&search=package:nlog.web-->
+	<variable name="layout"           value="${longdate} | [${level:uppercase=true}] ${message} ${exception:format=tostring}" />
+
+	<extensions>
+		<!--Enable NLog.Web for ASP.NET Core.-->
+		<add assembly="NLog.Web.AspNetCore" />
+	</extensions>
+
+	<targets>
+		<!-- Write logs to File -->
+		<target xsi:type="FallbackGroup"
+			name="fileGroup">
+			<target
+				name="fullfile"
+				xsi:type="File"
+				layout="${var:layout}"
+				fileName="${var:logHome}/full_${shortdate}.log"
+				keepFileOpen="false"
+				archiveFileName="${var:logHome}/Archive/full_${shortdate}.log"
+				archiveNumbering="Sequence"
+				archiveEvery="Day"
+				maxArchiveFiles="7"
+			/>
+		</target>
+
+		<!-- Write colored logs to Console -->
+		<target name="consoleLog" xsi:type="ColoredConsole" layout="[${uppercase:${level}}]: ${message}">
+			<highlight-word text="[TRACE]" foregroundColor="DarkGray" />
+			<highlight-word text="[Debug]" foregroundColor="Gray" />
+			<highlight-word text="[INFO]" foregroundColor="Green" />
+			<highlight-word text="[WARN]" foregroundColor="Yellow" />
+			<highlight-word text="[ERROR]" foregroundColor="Red" />
+			<highlight-word text="[FATAL]" foregroundColor="DarkRed" backgroundColor="White" />
+		</target>
+	</targets>
+
+
+	<rules>
+		<!--All logs, including Microsoft-->
+		<logger name="*" minlevel="${var:logLevel}" writeTo="fullfile" />
+
+		<!--Skip non-critical Microsoft logs and so log only own logs (BlackHole).-->
+		<logger name="Microsoft.*" maxlevel="Info" final="true" />
+		<logger name="System.Net.Http.*" maxlevel="Info" final="true" />
+		
+		<!--All logs, including from Microsoft, Level Info-->
+		<logger name="*" minlevel="${var:logLevel}" writeTo="consoleLog" />
+	</rules>
+</nlog>
\ No newline at end of file
diff --git a/src/OpenApiGeneratedConnector/.gitignore b/src/OpenApiGeneratedConnector/.gitignore
deleted file mode 100644
index 1ee53850b84cd478da00264a919c8180a746056e..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/.gitignore
+++ /dev/null
@@ -1,362 +0,0 @@
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-##
-## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
-
-# User-specific files
-*.rsuser
-*.suo
-*.user
-*.userosscache
-*.sln.docstates
-
-# User-specific files (MonoDevelop/Xamarin Studio)
-*.userprefs
-
-# Mono auto generated files
-mono_crash.*
-
-# Build results
-[Dd]ebug/
-[Dd]ebugPublic/
-[Rr]elease/
-[Rr]eleases/
-x64/
-x86/
-[Ww][Ii][Nn]32/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
-bld/
-[Bb]in/
-[Oo]bj/
-[Ll]og/
-[Ll]ogs/
-
-# Visual Studio 2015/2017 cache/options directory
-.vs/
-# Uncomment if you have tasks that create the project's static files in wwwroot
-#wwwroot/
-
-# Visual Studio 2017 auto generated files
-Generated\ Files/
-
-# MSTest test Results
-[Tt]est[Rr]esult*/
-[Bb]uild[Ll]og.*
-
-# NUnit
-*.VisualState.xml
-TestResult.xml
-nunit-*.xml
-
-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
-# Benchmark Results
-BenchmarkDotNet.Artifacts/
-
-# .NET Core
-project.lock.json
-project.fragment.lock.json
-artifacts/
-
-# ASP.NET Scaffolding
-ScaffoldingReadMe.txt
-
-# StyleCop
-StyleCopReport.xml
-
-# Files built by Visual Studio
-*_i.c
-*_p.c
-*_h.h
-*.ilk
-*.meta
-*.obj
-*.iobj
-*.pch
-*.pdb
-*.ipdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.tmp_proj
-*_wpftmp.csproj
-*.log
-*.vspscc
-*.vssscc
-.builds
-*.pidb
-*.svclog
-*.scc
-
-# Chutzpah Test files
-_Chutzpah*
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opendb
-*.opensdf
-*.sdf
-*.cachefile
-*.VC.db
-*.VC.VC.opendb
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-*.sap
-
-# Visual Studio Trace Files
-*.e2e
-
-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*/
-*.[Rr]e[Ss]harper
-*.DotSettings.user
-
-# TeamCity is a build add-in
-_TeamCity*
-
-# DotCover is a Code Coverage Tool
-*.dotCover
-
-# AxoCover is a Code Coverage Tool
-.axoCover/*
-!.axoCover/settings.json
-
-# Coverlet is a free, cross platform Code Coverage Tool
-coverage*.json
-coverage*.xml
-coverage*.info
-
-# Visual Studio code coverage results
-*.coverage
-*.coveragexml
-
-# NCrunch
-_NCrunch_*
-.*crunch*.local.xml
-nCrunchTemp_*
-
-# MightyMoose
-*.mm.*
-AutoTest.Net/
-
-# Web workbench (sass)
-.sass-cache/
-
-# Installshield output folder
-[Ee]xpress/
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish/
-
-# Publish Web Output
-*.[Pp]ublish.xml
-*.azurePubxml
-# Note: Comment the next line if you want to checkin your web deploy settings,
-# but database connection strings (with potential passwords) will be unencrypted
-*.pubxml
-*.publishproj
-
-# Microsoft Azure Web App publish settings. Comment the next line if you want to
-# checkin your Azure Web App publish settings, but sensitive information contained
-# in these scripts will be unencrypted
-PublishScripts/
-
-# NuGet Packages
-*.nupkg
-# NuGet Symbol Packages
-*.snupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
-# Uncomment if necessary however generally it will be regenerated when needed
-#!**/[Pp]ackages/repositories.config
-# NuGet v3's project.json files produces more ignorable files
-*.nuget.props
-*.nuget.targets
-
-# Microsoft Azure Build Output
-csx/
-*.build.csdef
-
-# Microsoft Azure Emulator
-ecf/
-rcf/
-
-# Windows Store app package directories and files
-AppPackages/
-BundleArtifacts/
-Package.StoreAssociation.xml
-_pkginfo.txt
-*.appx
-*.appxbundle
-*.appxupload
-
-# Visual Studio cache files
-# files ending in .cache can be ignored
-*.[Cc]ache
-# but keep track of directories ending in .cache
-!?*.[Cc]ache/
-
-# Others
-ClientBin/
-~$*
-*~
-*.dbmdl
-*.dbproj.schemaview
-*.jfm
-*.pfx
-*.publishsettings
-orleans.codegen.cs
-
-# Including strong name files can present a security risk
-# (https://github.com/github/gitignore/pull/2483#issue-259490424)
-#*.snk
-
-# Since there are multiple workflows, uncomment next line to ignore bower_components
-# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
-#bower_components/
-
-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project file
-# to a newer Visual Studio version. Backup files are not needed,
-# because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-ServiceFabricBackup/
-*.rptproj.bak
-
-# SQL Server files
-*.mdf
-*.ldf
-*.ndf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-*.rptproj.rsuser
-*- [Bb]ackup.rdl
-*- [Bb]ackup ([0-9]).rdl
-*- [Bb]ackup ([0-9][0-9]).rdl
-
-# Microsoft Fakes
-FakesAssemblies/
-
-# GhostDoc plugin setting file
-*.GhostDoc.xml
-
-# Node.js Tools for Visual Studio
-.ntvs_analysis.dat
-node_modules/
-
-# Visual Studio 6 build log
-*.plg
-
-# Visual Studio 6 workspace options file
-*.opt
-
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
-*.vbw
-
-# Visual Studio LightSwitch build output
-**/*.HTMLClient/GeneratedArtifacts
-**/*.DesktopClient/GeneratedArtifacts
-**/*.DesktopClient/ModelManifest.xml
-**/*.Server/GeneratedArtifacts
-**/*.Server/ModelManifest.xml
-_Pvt_Extensions
-
-# Paket dependency manager
-.paket/paket.exe
-paket-files/
-
-# FAKE - F# Make
-.fake/
-
-# CodeRush personal settings
-.cr/personal
-
-# Python Tools for Visual Studio (PTVS)
-__pycache__/
-*.pyc
-
-# Cake - Uncomment if you are using it
-# tools/**
-# !tools/packages.config
-
-# Tabs Studio
-*.tss
-
-# Telerik's JustMock configuration file
-*.jmconfig
-
-# BizTalk build output
-*.btp.cs
-*.btm.cs
-*.odx.cs
-*.xsd.cs
-
-# OpenCover UI analysis results
-OpenCover/
-
-# Azure Stream Analytics local run output
-ASALocalRun/
-
-# MSBuild Binary and Structured Log
-*.binlog
-
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-
-# MFractors (Xamarin productivity tool) working folder
-.mfractor/
-
-# Local History for Visual Studio
-.localhistory/
-
-# BeatPulse healthcheck temp database
-healthchecksdb
-
-# Backup folder for Package Reference Convert tool in Visual Studio 2017
-MigrationBackup/
-
-# Ionide (cross platform F# VS Code tools) working folder
-.ionide/
-
-# Fody - auto-generated XML schema
-FodyWeavers.xsd
diff --git a/src/OpenApiGeneratedConnector/.openapi-generator-ignore b/src/OpenApiGeneratedConnector/.openapi-generator-ignore
deleted file mode 100644
index 7484ee590a3894506cf063799b885428f95a71be..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/.openapi-generator-ignore
+++ /dev/null
@@ -1,23 +0,0 @@
-# OpenAPI Generator Ignore
-# Generated by openapi-generator https://github.com/openapitools/openapi-generator
-
-# Use this file to prevent files from being overwritten by the generator.
-# The patterns follow closely to .gitignore or .dockerignore.
-
-# As an example, the C# client generator defines ApiClient.cs.
-# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
-#ApiClient.cs
-
-# You can match any string of characters against a directory, file or extension with a single asterisk (*):
-#foo/*/qux
-# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
-
-# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
-#foo/**/qux
-# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
-
-# You can also negate patterns with an exclamation (!).
-# For example, you can ignore all files in a docs folder with the file extension .md:
-#docs/*.md
-# Then explicitly reverse the ignore rule for a single file:
-#!docs/README.md
diff --git a/src/OpenApiGeneratedConnector/OpenApiGeneratedConnector.csproj b/src/OpenApiGeneratedConnector/OpenApiGeneratedConnector.csproj
deleted file mode 100644
index ff12913ac5c3294f88b5eeeb67a1d619593280b7..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/OpenApiGeneratedConnector.csproj
+++ /dev/null
@@ -1,17 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  <Version>0.1.10</Version></PropertyGroup>
-
-
-  <ItemGroup>
-	<PackageReference Include="JsonSubTypes" Version="1.9.0" />
-	<PackageReference Include="Polly" Version="7.2.3" />
-	<PackageReference Include="RestSharp" Version="108.0.2" />
-	<PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
-  </ItemGroup>
-
-</Project>
diff --git a/src/OpenApiGeneratedConnector/README.md b/src/OpenApiGeneratedConnector/README.md
deleted file mode 100644
index 3a2117b74fbce1589377bde12c16da849bd3824a..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/README.md
+++ /dev/null
@@ -1,116 +0,0 @@
-# Org.OpenAPITools - the C# library for the Metadata Extractor API
-
-This API extracts RDF triples from files
-
-This C# SDK is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project:
-
-- API version: 0.1.1
-- SDK version: 1.0.0
-- Build package: org.openapitools.codegen.languages.CSharpNetCoreClientCodegen
-
-<a name="frameworks-supported"></a>
-## Frameworks supported
-- .NET Core >=1.0
-- .NET Framework >=4.6
-- Mono/Xamarin >=vNext
-
-<a name="dependencies"></a>
-## Dependencies
-
-- [RestSharp](https://www.nuget.org/packages/RestSharp) - 106.13.0 or later
-- [Json.NET](https://www.nuget.org/packages/Newtonsoft.Json/) - 13.0.1 or later
-- [JsonSubTypes](https://www.nuget.org/packages/JsonSubTypes/) - 1.8.0 or later
-- [System.ComponentModel.Annotations](https://www.nuget.org/packages/System.ComponentModel.Annotations) - 5.0.0 or later
-
-The DLLs included in the package may not be the latest version. We recommend using [NuGet](https://docs.nuget.org/consume/installing-nuget) to obtain the latest version of the packages:
-```
-Install-Package RestSharp
-Install-Package Newtonsoft.Json
-Install-Package JsonSubTypes
-Install-Package System.ComponentModel.Annotations
-```
-
-NOTE: RestSharp versions greater than 105.1.0 have a bug which causes file uploads to fail. See [RestSharp#742](https://github.com/restsharp/RestSharp/issues/742).
-NOTE: RestSharp for .Net Core creates a new socket for each api call, which can lead to a socket exhaustion problem. See [RestSharp#1406](https://github.com/restsharp/RestSharp/issues/1406).
-
-<a name="installation"></a>
-## Installation
-Generate the DLL using your preferred tool (e.g. `dotnet build`)
-
-Then include the DLL (under the `bin` folder) in the C# project, and use the namespaces:
-```csharp
-using Org.OpenAPITools.Api;
-using Org.OpenAPITools.Client;
-using Org.OpenAPITools.Model;
-```
-<a name="usage"></a>
-## Usage
-
-To use the API client with a HTTP proxy, setup a `System.Net.WebProxy`
-```csharp
-Configuration c = new Configuration();
-System.Net.WebProxy webProxy = new System.Net.WebProxy("http://myProxyUrl:80/");
-webProxy.Credentials = System.Net.CredentialCache.DefaultCredentials;
-c.Proxy = webProxy;
-```
-
-<a name="getting-started"></a>
-## Getting Started
-
-```csharp
-using System.Collections.Generic;
-using System.Diagnostics;
-using Org.OpenAPITools.Api;
-using Org.OpenAPITools.Client;
-using Org.OpenAPITools.Model;
-
-namespace Example
-{
-    public class Example
-    {
-        public static void Main()
-        {
-
-            Configuration config = new Configuration();
-            config.BasePath = "http://localhost";
-            var apiInstance = new DefaultApi(config);
-
-            try
-            {
-                apiInstance.GetConfigWorker();
-            }
-            catch (ApiException e)
-            {
-                Debug.Print("Exception when calling DefaultApi.GetConfigWorker: " + e.Message );
-                Debug.Print("Status Code: "+ e.ErrorCode);
-                Debug.Print(e.StackTrace);
-            }
-
-        }
-    }
-}
-```
-
-<a name="documentation-for-api-endpoints"></a>
-## Documentation for API Endpoints
-
-All URIs are relative to *http://localhost*
-
-Class | Method | HTTP request | Description
------------- | ------------- | ------------- | -------------
-*DefaultApi* | [**GetConfigWorker**](docs/DefaultApi.md#getconfigworker) | **GET** /defaultConfig | 
-*DefaultApi* | [**GetVersionWorker**](docs/DefaultApi.md#getversionworker) | **GET** /version | 
-*DefaultApi* | [**PostMetadataExtractorWorker**](docs/DefaultApi.md#postmetadataextractorworker) | **POST** / | 
-
-
-<a name="documentation-for-models"></a>
-## Documentation for Models
-
- - [Model.MetadataOutput](docs/MetadataOutput.md)
- - [Model.ModelVersion](docs/ModelVersion.md)
-
-
-<a name="documentation-for-authorization"></a>
-## Documentation for Authorization
-
-All endpoints do not require authorization.
diff --git a/src/OpenApiGeneratedConnector/appveyor.yml b/src/OpenApiGeneratedConnector/appveyor.yml
deleted file mode 100644
index f76f63cee506c8807857554d21b8d2693b9464d4..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/appveyor.yml
+++ /dev/null
@@ -1,9 +0,0 @@
-# auto-generated by OpenAPI Generator (https://github.com/OpenAPITools/openapi-generator)
-#
-image: Visual Studio 2019
-clone_depth: 1
-build_script:
-- dotnet build -c Release
-- dotnet test -c Release
-after_build:
-- dotnet pack .\src\Org.OpenAPITools\Org.OpenAPITools.csproj -o ../../output -c Release --no-build
diff --git a/src/OpenApiGeneratedConnector/docs/DefaultApi.md b/src/OpenApiGeneratedConnector/docs/DefaultApi.md
deleted file mode 100644
index 7c97e8ce8fa7e123ef08cdda2c37ede803aacbcc..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/docs/DefaultApi.md
+++ /dev/null
@@ -1,266 +0,0 @@
-# Org.OpenAPITools.Api.DefaultApi
-
-All URIs are relative to *http://localhost*
-
-| Method | HTTP request | Description |
-|--------|--------------|-------------|
-| [**GetConfigWorker**](DefaultApi.md#getconfigworker) | **GET** /defaultConfig |  |
-| [**GetVersionWorker**](DefaultApi.md#getversionworker) | **GET** /version |  |
-| [**PostMetadataExtractorWorker**](DefaultApi.md#postmetadataextractorworker) | **POST** / |  |
-
-<a name="getconfigworker"></a>
-# **GetConfigWorker**
-> void GetConfigWorker ()
-
-
-
-### Example
-```csharp
-using System.Collections.Generic;
-using System.Diagnostics;
-using Org.OpenAPITools.Api;
-using Org.OpenAPITools.Client;
-using Org.OpenAPITools.Model;
-
-namespace Example
-{
-    public class GetConfigWorkerExample
-    {
-        public static void Main()
-        {
-            Configuration config = new Configuration();
-            config.BasePath = "http://localhost";
-            var apiInstance = new DefaultApi(config);
-
-            try
-            {
-                apiInstance.GetConfigWorker();
-            }
-            catch (ApiException  e)
-            {
-                Debug.Print("Exception when calling DefaultApi.GetConfigWorker: " + e.Message);
-                Debug.Print("Status Code: " + e.ErrorCode);
-                Debug.Print(e.StackTrace);
-            }
-        }
-    }
-}
-```
-
-#### Using the GetConfigWorkerWithHttpInfo variant
-This returns an ApiResponse object which contains the response data, status code and headers.
-
-```csharp
-try
-{
-    apiInstance.GetConfigWorkerWithHttpInfo();
-}
-catch (ApiException e)
-{
-    Debug.Print("Exception when calling DefaultApi.GetConfigWorkerWithHttpInfo: " + e.Message);
-    Debug.Print("Status Code: " + e.ErrorCode);
-    Debug.Print(e.StackTrace);
-}
-```
-
-### Parameters
-This endpoint does not need any parameter.
-### Return type
-
-void (empty response body)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: Not defined
-
-
-### HTTP response details
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-| **200** | Success |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-<a name="getversionworker"></a>
-# **GetVersionWorker**
-> ModelVersion GetVersionWorker ()
-
-
-
-### Example
-```csharp
-using System.Collections.Generic;
-using System.Diagnostics;
-using Org.OpenAPITools.Api;
-using Org.OpenAPITools.Client;
-using Org.OpenAPITools.Model;
-
-namespace Example
-{
-    public class GetVersionWorkerExample
-    {
-        public static void Main()
-        {
-            Configuration config = new Configuration();
-            config.BasePath = "http://localhost";
-            var apiInstance = new DefaultApi(config);
-
-            try
-            {
-                ModelVersion result = apiInstance.GetVersionWorker();
-                Debug.WriteLine(result);
-            }
-            catch (ApiException  e)
-            {
-                Debug.Print("Exception when calling DefaultApi.GetVersionWorker: " + e.Message);
-                Debug.Print("Status Code: " + e.ErrorCode);
-                Debug.Print(e.StackTrace);
-            }
-        }
-    }
-}
-```
-
-#### Using the GetVersionWorkerWithHttpInfo variant
-This returns an ApiResponse object which contains the response data, status code and headers.
-
-```csharp
-try
-{
-    ApiResponse<ModelVersion> response = apiInstance.GetVersionWorkerWithHttpInfo();
-    Debug.Write("Status Code: " + response.StatusCode);
-    Debug.Write("Response Headers: " + response.Headers);
-    Debug.Write("Response Body: " + response.Data);
-}
-catch (ApiException e)
-{
-    Debug.Print("Exception when calling DefaultApi.GetVersionWorkerWithHttpInfo: " + e.Message);
-    Debug.Print("Status Code: " + e.ErrorCode);
-    Debug.Print(e.StackTrace);
-}
-```
-
-### Parameters
-This endpoint does not need any parameter.
-### Return type
-
-[**ModelVersion**](ModelVersion.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: Not defined
- - **Accept**: application/json
-
-
-### HTTP response details
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-| **200** | Success |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
-<a name="postmetadataextractorworker"></a>
-# **PostMetadataExtractorWorker**
-> List&lt;MetadataOutput&gt; PostMetadataExtractorWorker (System.IO.Stream file, string identifier = null, string config = null, string creationDate = null, string modificationDate = null)
-
-
-
-### Example
-```csharp
-using System.Collections.Generic;
-using System.Diagnostics;
-using Org.OpenAPITools.Api;
-using Org.OpenAPITools.Client;
-using Org.OpenAPITools.Model;
-
-namespace Example
-{
-    public class PostMetadataExtractorWorkerExample
-    {
-        public static void Main()
-        {
-            Configuration config = new Configuration();
-            config.BasePath = "http://localhost";
-            var apiInstance = new DefaultApi(config);
-            var file = new System.IO.MemoryStream(System.IO.File.ReadAllBytes("/path/to/file.txt"));  // System.IO.Stream | 
-            var identifier = "identifier_example";  // string | File Identifier (optional) 
-            var config = "config_example";  // string | Object defining the utilized configuration (try \\\"/defaultConfig\\\" to get the structure) (optional) 
-            var creationDate = "creationDate_example";  // string | Creation Date (Time) (e.g. \\\"2022-09-15T09:27:17.3550000+02:00\\\") (optional) 
-            var modificationDate = "modificationDate_example";  // string | Modification Date (Time) (e.g. \\\"2022-09-15T09:27:17.3550000+02:00\\\") (optional) 
-
-            try
-            {
-                List<MetadataOutput> result = apiInstance.PostMetadataExtractorWorker(file, identifier, config, creationDate, modificationDate);
-                Debug.WriteLine(result);
-            }
-            catch (ApiException  e)
-            {
-                Debug.Print("Exception when calling DefaultApi.PostMetadataExtractorWorker: " + e.Message);
-                Debug.Print("Status Code: " + e.ErrorCode);
-                Debug.Print(e.StackTrace);
-            }
-        }
-    }
-}
-```
-
-#### Using the PostMetadataExtractorWorkerWithHttpInfo variant
-This returns an ApiResponse object which contains the response data, status code and headers.
-
-```csharp
-try
-{
-    ApiResponse<List<MetadataOutput>> response = apiInstance.PostMetadataExtractorWorkerWithHttpInfo(file, identifier, config, creationDate, modificationDate);
-    Debug.Write("Status Code: " + response.StatusCode);
-    Debug.Write("Response Headers: " + response.Headers);
-    Debug.Write("Response Body: " + response.Data);
-}
-catch (ApiException e)
-{
-    Debug.Print("Exception when calling DefaultApi.PostMetadataExtractorWorkerWithHttpInfo: " + e.Message);
-    Debug.Print("Status Code: " + e.ErrorCode);
-    Debug.Print(e.StackTrace);
-}
-```
-
-### Parameters
-
-| Name | Type | Description | Notes |
-|------|------|-------------|-------|
-| **file** | **System.IO.Stream****System.IO.Stream** |  |  |
-| **identifier** | **string** | File Identifier | [optional]  |
-| **config** | **string** | Object defining the utilized configuration (try \\\&quot;/defaultConfig\\\&quot; to get the structure) | [optional]  |
-| **creationDate** | **string** | Creation Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) | [optional]  |
-| **modificationDate** | **string** | Modification Date (Time) (e.g. \\\&quot;2022-09-15T09:27:17.3550000+02:00\\\&quot;) | [optional]  |
-
-### Return type
-
-[**List&lt;MetadataOutput&gt;**](MetadataOutput.md)
-
-### Authorization
-
-No authorization required
-
-### HTTP request headers
-
- - **Content-Type**: multipart/form-data
- - **Accept**: application/json
-
-
-### HTTP response details
-| Status code | Description | Response headers |
-|-------------|-------------|------------------|
-| **400** | Bad Request |  -  |
-| **200** | Success |  -  |
-
-[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
-
diff --git a/src/OpenApiGeneratedConnector/docs/MetadataOutput.md b/src/OpenApiGeneratedConnector/docs/MetadataOutput.md
deleted file mode 100644
index 0897e68f7438c411cc6d2e94886748ecc20be545..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/docs/MetadataOutput.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Org.OpenAPITools.Model.MetadataOutput
-
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**Identifier** | **string** |  | [optional] 
-**Metadata** | **string** |  | [optional] 
-**Text** | **string** |  | [optional] 
-
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
diff --git a/src/OpenApiGeneratedConnector/docs/ModelVersion.md b/src/OpenApiGeneratedConnector/docs/ModelVersion.md
deleted file mode 100644
index 2b00f35278a07628356c36fd7c3201905fd48890..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/docs/ModelVersion.md
+++ /dev/null
@@ -1,10 +0,0 @@
-# Org.OpenAPITools.Model.ModelVersion
-
-## Properties
-
-Name | Type | Description | Notes
------------- | ------------- | ------------- | -------------
-**_Version** | **string** |  | [optional] 
-
-[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
-
diff --git a/src/OpenApiGeneratedConnector/git_push.sh b/src/OpenApiGeneratedConnector/git_push.sh
deleted file mode 100644
index f53a75d4fabe760cce49eddfd62fcc702938ea90..0000000000000000000000000000000000000000
--- a/src/OpenApiGeneratedConnector/git_push.sh
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/bin/sh
-# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
-#
-# Usage example: /bin/sh ./git_push.sh wing328 openapi-petstore-perl "minor update" "gitlab.com"
-
-git_user_id=$1
-git_repo_id=$2
-release_note=$3
-git_host=$4
-
-if [ "$git_host" = "" ]; then
-    git_host="github.com"
-    echo "[INFO] No command line input provided. Set \$git_host to $git_host"
-fi
-
-if [ "$git_user_id" = "" ]; then
-    git_user_id="GIT_USER_ID"
-    echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id"
-fi
-
-if [ "$git_repo_id" = "" ]; then
-    git_repo_id="GIT_REPO_ID"
-    echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id"
-fi
-
-if [ "$release_note" = "" ]; then
-    release_note="Minor update"
-    echo "[INFO] No command line input provided. Set \$release_note to $release_note"
-fi
-
-# Initialize the local directory as a Git repository
-git init
-
-# Adds the files in the local repository and stages them for commit.
-git add .
-
-# Commits the tracked changes and prepares them to be pushed to a remote repository.
-git commit -m "$release_note"
-
-# Sets the new remote
-git_remote=$(git remote)
-if [ "$git_remote" = "" ]; then # git remote not defined
-
-    if [ "$GIT_TOKEN" = "" ]; then
-        echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment."
-        git remote add origin https://${git_host}/${git_user_id}/${git_repo_id}.git
-    else
-        git remote add origin https://${git_user_id}:"${GIT_TOKEN}"@${git_host}/${git_user_id}/${git_repo_id}.git
-    fi
-
-fi
-
-git pull origin master
-
-# Pushes (Forces) the changes in the local repository up to the remote repository
-echo "Git pushing to https://${git_host}/${git_user_id}/${git_repo_id}.git"
-git push origin master 2>&1 | grep -v 'To https'