feat(specs): add compositions deduplication setting (generated)

algolia/api-clients-automation#5418

Co-authored-by: algolia-bot <[email protected]>
Co-authored-by: Ben Kalmus <[email protected]>
Co-authored-by: Clara Muller <[email protected]>

Author: 3 people

Sources/Composition/Models/DedupPositioning.swift

@@ -0,0 +1,19 @@
+// Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on
+// https://github.com/algolia/api-clients-automation. DO NOT EDIT.
+
+import Foundation
+#if canImport(Core)
+    import Core
+#endif
+
+/// Deduplication positioning configures how a duplicate result should be resolved between an injected item and main
+/// search results. Current configuration supports: - 'highest': always select the item in the highest position, and
+/// remove duplicates that appear lower in the results. - 'highestInjected': duplicate result will be moved to its
+/// highest possible injected position, but not higher.    If a duplicate appears higher in main search results, it will
+/// be removed to stay it's intended group position (which could be lower than main).
+public enum DedupPositioning: String, Codable, CaseIterable {
+    case highest
+    case highestInjected
+}
+
+extension DedupPositioning: Hashable {}

Sources/Composition/Models/Deduplication.swift

@@ -0,0 +1,40 @@
+// Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on
+// https://github.com/algolia/api-clients-automation. DO NOT EDIT.
+
+import Foundation
+#if canImport(Core)
+    import Core
+#endif
+
+/// Deduplication configures the methods used to resolve duplicate items between main search results and injected group
+/// results.
+public struct Deduplication: Codable, JSONEncodable {
+    public var positioning: DedupPositioning
+
+    public init(positioning: DedupPositioning) {
+        self.positioning = positioning
+    }
+
+    public enum CodingKeys: String, CodingKey, CaseIterable {
+        case positioning
+    }
+
+    // Encodable protocol methods
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.positioning, forKey: .positioning)
+    }
+}
+
+extension Deduplication: Equatable {
+    public static func ==(lhs: Deduplication, rhs: Deduplication) -> Bool {
+        lhs.positioning == rhs.positioning
+    }
+}
+
+extension Deduplication: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.positioning.hashValue)
+    }
+}

Sources/Composition/Models/Injection.swift

@@ -10,15 +10,18 @@ public struct Injection: Codable, JSONEncodable {
     public var main: CompositionMain
     /// list of injected items of the current Composition.
     public var injectedItems: [InjectedItem]?
+    public var deduplication: Deduplication?
 
-    public init(main: CompositionMain, injectedItems: [InjectedItem]? = nil) {
+    public init(main: CompositionMain, injectedItems: [InjectedItem]? = nil, deduplication: Deduplication? = nil) {
         self.main = main
         self.injectedItems = injectedItems
+        self.deduplication = deduplication
     }
 
     public enum CodingKeys: String, CodingKey, CaseIterable {
         case main
         case injectedItems
+        case deduplication
     }
 
     // Encodable protocol methods
@@ -27,19 +30,22 @@ public struct Injection: Codable, JSONEncodable {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(self.main, forKey: .main)
         try container.encodeIfPresent(self.injectedItems, forKey: .injectedItems)
+        try container.encodeIfPresent(self.deduplication, forKey: .deduplication)
     }
 }
 
 extension Injection: Equatable {
     public static func ==(lhs: Injection, rhs: Injection) -> Bool {
         lhs.main == rhs.main &&
-            lhs.injectedItems == rhs.injectedItems
+            lhs.injectedItems == rhs.injectedItems &&
+            lhs.deduplication == rhs.deduplication
     }
 }
 
 extension Injection: Hashable {
     public func hash(into hasher: inout Hasher) {
         hasher.combine(self.main.hashValue)
         hasher.combine(self.injectedItems?.hashValue)
+        hasher.combine(self.deduplication?.hashValue)
     }
 }