fix(dotnet): make it being able to pack as nuget package

Fixed all the errors I got on running
`dotnet pack --configuration Release`

src/aidbox_sdk/converter.clj

@@ -197,6 +197,7 @@
                                           (url->resource-name (get schema :base)))
                     :fhir-version (get schema :fhir-version)
                     :package (get schema :package)
+                    :service-type? (fhir/service-type? schema)
                     :url (get schema :url)
                     :type (get schema :type)
                     :derivation (get schema :derivation))))))
@@ -216,6 +217,23 @@
                  x))
              elements))))
 
+(defn add-service-type-flag
+  "Adds `service-type` flag to each element. The value will be `true` if type of
+  element belongs to service-types, and `false` otherwise."
+  [schema]
+  (letfn [(update-elements [elements]
+            (walk/postwalk
+             (fn [x]
+               (if (:type x)
+                 (let [service-type? (fhir/service-type-element? (:fhir-version schema) x)]
+                   (assoc x :service-type service-type?))
+                 x))
+             elements))]
+    (-> schema
+        (update :elements update-elements)
+        (update :backbone-elements (fn [backbone-elements]
+                                     (for [backbone backbone-elements]
+                                       (update backbone :elements update-elements)))))))
 ;;
 
 (defn find-elements-by-names [element-names schema]
@@ -267,7 +285,6 @@
 ;; Convert main function
 ;;
 
-
 (defn convert [schemas]
   (->> schemas
        (map resolve-element-references)
@@ -276,7 +293,8 @@
        (map (fn [schema]
               (update schema :backbone-elements #(resolve-choices (flatten-backbones % [])))))
        (resolve-choices)
-       (resolve-dependencies)))
+       (resolve-dependencies)
+       (map add-service-type-flag)))
 
 ;;
 ;; Search Params

src/aidbox_sdk/fhir.clj

@@ -5,7 +5,10 @@
 
 ;; Base Types and Datatypes
 
-(def r4-base-types #{"Element" "Resource" "DomainResource"})
+(def r4-base-types #{"Element" "Resource" "DomainResource"
+                     ;; NOTE: technically `Bundle` is not a base type,
+                     ;; but it's here for a reason.
+                     "Bundle"})
 
 (def r4-primitive-types
   #{"boolean" "integer" "string" "decimal" "uri" "url" "canonical" "base64Binary"
@@ -32,6 +35,13 @@
              r4-metadata-types
              r4-special-purpose-datatypes))
 
+(def r4-service-types
+  "This is special set of types that are not represented in FHIR in no way,
+  but are needed for SDK generation. Essentially, service schemas are:
+  base types + datatypes - primitive-types."
+  (set/union (set/difference r4-datatypes r4-primitive-types)
+             r4-base-types))
+
 (def r4b-base-types r4-base-types)
 
 (def r4b-primitive-types r4-primitive-types)
@@ -51,6 +61,13 @@
              r4b-metadata-types
              r4b-special-purpose-datatypes))
 
+(def r4b-service-types
+  "This is special set of types that are not represented in FHIR in no way,
+  but are needed for SDK generation. Essentially, service schemas are:
+  base types + datatypes - primitive-types."
+  (set/union (set/difference r4b-datatypes r4b-primitive-types)
+             r4b-base-types))
+
 (def r5-base-types
   #{"Base" "Element" "BackboneElement" "DataType" "PrimitiveType" "BackboneType"
     "Resource" "DomainResource" "CanonicalResource" "MetadataResource"})
@@ -73,6 +90,13 @@
              r5-metadata-types
              r5-special-purpose-datatypes))
 
+(def r5-service-types
+  "This is special set of types that are not represented in FHIR in no way,
+  but are needed for SDK generation. Essentially, service schemas are:
+  base types + datatypes - primitive-types."
+  (set/union (set/difference r5-datatypes r5-primitive-types)
+             r5-base-types))
+
 ;; Predicates
 (defn resource-type-pred [rt]   (fn [schema] (= rt (:resourceType schema))))
 (defn kind-pred          [kind] (fn [schema] (= kind (:kind schema))))
@@ -162,3 +186,13 @@
 
 (defn base-package? [schema]
   (contains? #{"hl7.fhir.r4.core" "hl7.fhir.r4b.core" "hl7.fhir.r5.core"} (:package schema)))
+
+(defmulti service-type? :fhir-version)
+(defmethod service-type? "hl7.fhir.r4.core"  [schema] (contains? r4-service-types  (:id schema)))
+(defmethod service-type? "hl7.fhir.r4b.core" [schema] (contains? r4b-service-types (:id schema)))
+(defmethod service-type? "hl7.fhir.r5.core"  [schema] (contains? r5-service-types  (:id schema)))
+
+(defmulti service-type-element? (fn [package _element] package))
+(defmethod service-type-element? "hl7.fhir.r4.core"  [_ {:keys [type]}] (contains? r4-service-types  type))
+(defmethod service-type-element? "hl7.fhir.r4b.core" [_ {:keys [type]}] (contains? r4b-service-types type))
+(defmethod service-type-element? "hl7.fhir.r5.core"  [_ {:keys [type]}] (contains? r5-service-types  type))