@maydon_tech/react-native-nitro-maps 0.1.0 → 0.1.1

package/nitrogen/generated/ios/swift/ClusterConfig.swift

@@ -19,29 +19,113 @@ public extension ClusterConfig {
   /**
    * Create a new instance of `ClusterConfig`.
    */
-  init(enabled: Bool, strategy: ClusterStrategy, radius: Double, minimumClusterSize: Double, maxZoom: Double, backgroundColor: ColorValue, textColor: ColorValue, borderWidth: Double, borderColor: ColorValue, animatesClusters: Bool, animationDuration: Double, animationStyle: ClusterAnimationStyle, realtimeClustering: Bool, renderBuffer: Double, throttleInterval: Double) {
-    self.init(enabled, strategy, radius, minimumClusterSize, maxZoom, { () -> bridge.std__variant_std__string__MarkerColor_ in
-      switch backgroundColor {
-        case .first(let __value):
-          return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
-        case .second(let __value):
-          return bridge.create_std__variant_std__string__MarkerColor_(__value)
+  init(enabled: Bool, strategy: ClusterStrategy?, radius: Double?, minimumClusterSize: Double?, maxZoom: Double?, backgroundColor: Variant_String_MarkerColor?, textColor: Variant_String_MarkerColor?, borderWidth: Double?, borderColor: Variant_String_MarkerColor?, animatesClusters: Bool?, animationDuration: Double?, animationStyle: ClusterAnimationStyle?, realtimeClustering: Bool?, renderBuffer: Double?, throttleInterval: Double?) {
+    self.init(enabled, { () -> bridge.std__optional_ClusterStrategy_ in
+      if let __unwrappedValue = strategy {
+        return bridge.create_std__optional_ClusterStrategy_(__unwrappedValue)
+      } else {
+        return .init()
       }
-    }().variant, { () -> bridge.std__variant_std__string__MarkerColor_ in
-      switch textColor {
-        case .first(let __value):
-          return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
-        case .second(let __value):
-          return bridge.create_std__variant_std__string__MarkerColor_(__value)
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = radius {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
       }
-    }().variant, borderWidth, { () -> bridge.std__variant_std__string__MarkerColor_ in
-      switch borderColor {
-        case .first(let __value):
-          return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
-        case .second(let __value):
-          return bridge.create_std__variant_std__string__MarkerColor_(__value)
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = minimumClusterSize {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
       }
-    }().variant, animatesClusters, animationDuration, animationStyle, realtimeClustering, renderBuffer, throttleInterval)
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = maxZoom {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_std__string__MarkerColor__ in
+      if let __unwrappedValue = backgroundColor {
+        return bridge.create_std__optional_std__variant_std__string__MarkerColor__({ () -> bridge.std__variant_std__string__MarkerColor_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
+            case .second(let __value):
+              return bridge.create_std__variant_std__string__MarkerColor_(__value)
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_std__string__MarkerColor__ in
+      if let __unwrappedValue = textColor {
+        return bridge.create_std__optional_std__variant_std__string__MarkerColor__({ () -> bridge.std__variant_std__string__MarkerColor_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
+            case .second(let __value):
+              return bridge.create_std__variant_std__string__MarkerColor_(__value)
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = borderWidth {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__variant_std__string__MarkerColor__ in
+      if let __unwrappedValue = borderColor {
+        return bridge.create_std__optional_std__variant_std__string__MarkerColor__({ () -> bridge.std__variant_std__string__MarkerColor_ in
+          switch __unwrappedValue {
+            case .first(let __value):
+              return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
+            case .second(let __value):
+              return bridge.create_std__variant_std__string__MarkerColor_(__value)
+          }
+        }().variant)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = animatesClusters {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = animationDuration {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_ClusterAnimationStyle_ in
+      if let __unwrappedValue = animationStyle {
+        return bridge.create_std__optional_ClusterAnimationStyle_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = realtimeClustering {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = renderBuffer {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = throttleInterval {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
   }
 
   var enabled: Bool {
@@ -55,214 +139,333 @@ public extension ClusterConfig {
     }
   }
   
-  var strategy: ClusterStrategy {
+  var strategy: ClusterStrategy? {
     @inline(__always)
     get {
-      return self.__strategy
+      return self.__strategy.value
     }
     @inline(__always)
     set {
-      self.__strategy = newValue
+      self.__strategy = { () -> bridge.std__optional_ClusterStrategy_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_ClusterStrategy_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var radius: Double {
+  var radius: Double? {
     @inline(__always)
     get {
-      return self.__radius
+      return self.__radius.value
     }
     @inline(__always)
     set {
-      self.__radius = newValue
+      self.__radius = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var minimumClusterSize: Double {
+  var minimumClusterSize: Double? {
     @inline(__always)
     get {
-      return self.__minimumClusterSize
+      return self.__minimumClusterSize.value
     }
     @inline(__always)
     set {
-      self.__minimumClusterSize = newValue
+      self.__minimumClusterSize = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var maxZoom: Double {
+  var maxZoom: Double? {
     @inline(__always)
     get {
-      return self.__maxZoom
+      return self.__maxZoom.value
     }
     @inline(__always)
     set {
-      self.__maxZoom = newValue
+      self.__maxZoom = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var backgroundColor: ColorValue {
+  var backgroundColor: Variant_String_MarkerColor? {
     @inline(__always)
     get {
-      return { () -> ColorValue in
-        let __variant = bridge.std__variant_std__string__MarkerColor_(self.__backgroundColor)
-        switch __variant.index() {
-          case 0:
-            let __actual = __variant.get_0()
-            return .first(String(__actual))
-          case 1:
-            let __actual = __variant.get_1()
-            return .second(__actual)
-          default:
-            fatalError("Variant can never have index \(__variant.index())!")
+      return { () -> Variant_String_MarkerColor? in
+        if bridge.has_value_std__optional_std__variant_std__string__MarkerColor__(self.__backgroundColor) {
+          let __unwrapped = bridge.get_std__optional_std__variant_std__string__MarkerColor__(self.__backgroundColor)
+          return { () -> Variant_String_MarkerColor in
+            let __variant = bridge.std__variant_std__string__MarkerColor_(__unwrapped)
+            switch __variant.index() {
+              case 0:
+                let __actual = __variant.get_0()
+                return .first(String(__actual))
+              case 1:
+                let __actual = __variant.get_1()
+                return .second(__actual)
+              default:
+                fatalError("Variant can never have index \(__variant.index())!")
+            }
+          }()
+        } else {
+          return nil
         }
       }()
     }
     @inline(__always)
     set {
-      self.__backgroundColor = { () -> bridge.std__variant_std__string__MarkerColor_ in
-        switch newValue {
-          case .first(let __value):
-            return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
-          case .second(let __value):
-            return bridge.create_std__variant_std__string__MarkerColor_(__value)
+      self.__backgroundColor = { () -> bridge.std__optional_std__variant_std__string__MarkerColor__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__variant_std__string__MarkerColor__({ () -> bridge.std__variant_std__string__MarkerColor_ in
+            switch __unwrappedValue {
+              case .first(let __value):
+                return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
+              case .second(let __value):
+                return bridge.create_std__variant_std__string__MarkerColor_(__value)
+            }
+          }().variant)
+        } else {
+          return .init()
         }
-      }().variant
+      }()
     }
   }
   
-  var textColor: ColorValue {
+  var textColor: Variant_String_MarkerColor? {
     @inline(__always)
     get {
-      return { () -> ColorValue in
-        let __variant = bridge.std__variant_std__string__MarkerColor_(self.__textColor)
-        switch __variant.index() {
-          case 0:
-            let __actual = __variant.get_0()
-            return .first(String(__actual))
-          case 1:
-            let __actual = __variant.get_1()
-            return .second(__actual)
-          default:
-            fatalError("Variant can never have index \(__variant.index())!")
+      return { () -> Variant_String_MarkerColor? in
+        if bridge.has_value_std__optional_std__variant_std__string__MarkerColor__(self.__textColor) {
+          let __unwrapped = bridge.get_std__optional_std__variant_std__string__MarkerColor__(self.__textColor)
+          return { () -> Variant_String_MarkerColor in
+            let __variant = bridge.std__variant_std__string__MarkerColor_(__unwrapped)
+            switch __variant.index() {
+              case 0:
+                let __actual = __variant.get_0()
+                return .first(String(__actual))
+              case 1:
+                let __actual = __variant.get_1()
+                return .second(__actual)
+              default:
+                fatalError("Variant can never have index \(__variant.index())!")
+            }
+          }()
+        } else {
+          return nil
         }
       }()
     }
     @inline(__always)
     set {
-      self.__textColor = { () -> bridge.std__variant_std__string__MarkerColor_ in
-        switch newValue {
-          case .first(let __value):
-            return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
-          case .second(let __value):
-            return bridge.create_std__variant_std__string__MarkerColor_(__value)
+      self.__textColor = { () -> bridge.std__optional_std__variant_std__string__MarkerColor__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__variant_std__string__MarkerColor__({ () -> bridge.std__variant_std__string__MarkerColor_ in
+            switch __unwrappedValue {
+              case .first(let __value):
+                return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
+              case .second(let __value):
+                return bridge.create_std__variant_std__string__MarkerColor_(__value)
+            }
+          }().variant)
+        } else {
+          return .init()
         }
-      }().variant
+      }()
     }
   }
   
-  var borderWidth: Double {
+  var borderWidth: Double? {
     @inline(__always)
     get {
-      return self.__borderWidth
+      return self.__borderWidth.value
     }
     @inline(__always)
     set {
-      self.__borderWidth = newValue
+      self.__borderWidth = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var borderColor: ColorValue {
+  var borderColor: Variant_String_MarkerColor? {
     @inline(__always)
     get {
-      return { () -> ColorValue in
-        let __variant = bridge.std__variant_std__string__MarkerColor_(self.__borderColor)
-        switch __variant.index() {
-          case 0:
-            let __actual = __variant.get_0()
-            return .first(String(__actual))
-          case 1:
-            let __actual = __variant.get_1()
-            return .second(__actual)
-          default:
-            fatalError("Variant can never have index \(__variant.index())!")
+      return { () -> Variant_String_MarkerColor? in
+        if bridge.has_value_std__optional_std__variant_std__string__MarkerColor__(self.__borderColor) {
+          let __unwrapped = bridge.get_std__optional_std__variant_std__string__MarkerColor__(self.__borderColor)
+          return { () -> Variant_String_MarkerColor in
+            let __variant = bridge.std__variant_std__string__MarkerColor_(__unwrapped)
+            switch __variant.index() {
+              case 0:
+                let __actual = __variant.get_0()
+                return .first(String(__actual))
+              case 1:
+                let __actual = __variant.get_1()
+                return .second(__actual)
+              default:
+                fatalError("Variant can never have index \(__variant.index())!")
+            }
+          }()
+        } else {
+          return nil
         }
       }()
     }
     @inline(__always)
     set {
-      self.__borderColor = { () -> bridge.std__variant_std__string__MarkerColor_ in
-        switch newValue {
-          case .first(let __value):
-            return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
-          case .second(let __value):
-            return bridge.create_std__variant_std__string__MarkerColor_(__value)
+      self.__borderColor = { () -> bridge.std__optional_std__variant_std__string__MarkerColor__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__variant_std__string__MarkerColor__({ () -> bridge.std__variant_std__string__MarkerColor_ in
+            switch __unwrappedValue {
+              case .first(let __value):
+                return bridge.create_std__variant_std__string__MarkerColor_(std.string(__value))
+              case .second(let __value):
+                return bridge.create_std__variant_std__string__MarkerColor_(__value)
+            }
+          }().variant)
+        } else {
+          return .init()
         }
-      }().variant
+      }()
     }
   }
   
-  var animatesClusters: Bool {
+  var animatesClusters: Bool? {
     @inline(__always)
     get {
-      return self.__animatesClusters
+      return { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(self.__animatesClusters) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__animatesClusters)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__animatesClusters = newValue
+      self.__animatesClusters = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var animationDuration: Double {
+  var animationDuration: Double? {
     @inline(__always)
     get {
-      return self.__animationDuration
+      return self.__animationDuration.value
     }
     @inline(__always)
     set {
-      self.__animationDuration = newValue
+      self.__animationDuration = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var animationStyle: ClusterAnimationStyle {
+  var animationStyle: ClusterAnimationStyle? {
     @inline(__always)
     get {
-      return self.__animationStyle
+      return self.__animationStyle.value
     }
     @inline(__always)
     set {
-      self.__animationStyle = newValue
+      self.__animationStyle = { () -> bridge.std__optional_ClusterAnimationStyle_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_ClusterAnimationStyle_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var realtimeClustering: Bool {
+  var realtimeClustering: Bool? {
     @inline(__always)
     get {
-      return self.__realtimeClustering
+      return { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(self.__realtimeClustering) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__realtimeClustering)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
     }
     @inline(__always)
     set {
-      self.__realtimeClustering = newValue
+      self.__realtimeClustering = { () -> bridge.std__optional_bool_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_bool_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var renderBuffer: Double {
+  var renderBuffer: Double? {
     @inline(__always)
     get {
-      return self.__renderBuffer
+      return self.__renderBuffer.value
     }
     @inline(__always)
     set {
-      self.__renderBuffer = newValue
+      self.__renderBuffer = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
   
-  var throttleInterval: Double {
+  var throttleInterval: Double? {
     @inline(__always)
     get {
-      return self.__throttleInterval
+      return self.__throttleInterval.value
     }
     @inline(__always)
     set {
-      self.__throttleInterval = newValue
+      self.__throttleInterval = { () -> bridge.std__optional_double_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_double_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
     }
   }
 }