feat(specs): add estimate path and responses [skip-bc] (generated)

algolia/api-clients-automation#4057

Co-authored-by: algolia-bot <[email protected]>
Co-authored-by: Christopher Hawke <[email protected]>
Co-authored-by: Pierre Millot <[email protected]>

Author: 3 people

Sources/Abtesting/AbtestingClient.swift

@@ -384,6 +384,53 @@ open class AbtestingClient {
         )
     }
 
+    /// - parameter estimateABTestRequest: (body)
+    /// - returns: EstimateABTestResponse
+    @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
+    open func estimateABTest(
+        estimateABTestRequest: EstimateABTestRequest,
+        requestOptions: RequestOptions? = nil
+    ) async throws -> EstimateABTestResponse {
+        let response: Response<EstimateABTestResponse> = try await estimateABTestWithHTTPInfo(
+            estimateABTestRequest: estimateABTestRequest,
+            requestOptions: requestOptions
+        )
+
+        guard let body = response.body else {
+            throw AlgoliaError.missingData
+        }
+
+        return body
+    }
+
+    // Given the traffic percentage and the expected effect size, this endpoint estimates the sample size and duration
+    // of an A/B test based on historical traffic.
+    // Required API Key ACLs:
+    //  - analytics
+    //
+    // - parameter estimateABTestRequest: (body)
+    // - returns: RequestBuilder<EstimateABTestResponse>
+
+    open func estimateABTestWithHTTPInfo(
+        estimateABTestRequest: EstimateABTestRequest,
+        requestOptions userRequestOptions: RequestOptions? = nil
+    ) async throws -> Response<EstimateABTestResponse> {
+        let resourcePath = "/2/abtests/estimate"
+        let body = estimateABTestRequest
+        let queryParameters: [String: Any?]? = nil
+
+        let nillableHeaders: [String: Any?]? = nil
+
+        let headers = APIHelper.rejectNilHeaders(nillableHeaders)
+
+        return try await self.transporter.send(
+            method: "POST",
+            path: resourcePath,
+            data: body,
+            requestOptions: RequestOptions(headers: headers, queryParameters: queryParameters) + userRequestOptions
+        )
+    }
+
     /// - parameter id: (path) Unique A/B test identifier.
     /// - returns: ABTest
     @available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)

Sources/Abtesting/Models/Effect.swift renamed to Sources/Abtesting/Models/EffectMetric.swift

@@ -7,11 +7,11 @@ import Foundation
 #endif
 
 /// Metric for which you want to detect the smallest relative difference.
-public enum Effect: String, Codable, CaseIterable {
+public enum EffectMetric: String, Codable, CaseIterable {
     case addToCartRate
     case clickThroughRate
     case conversionRate
     case purchaseRate
 }
 
-extension Effect: Hashable {}
+extension EffectMetric: Hashable {}

Sources/Abtesting/Models/EstimateABTestRequest.swift

@@ -0,0 +1,45 @@
+// 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
+
+public struct EstimateABTestRequest: Codable, JSONEncodable {
+    public var configuration: EstimateConfiguration
+    /// A/B test variants.
+    public var variants: [AddABTestsVariant]
+
+    public init(configuration: EstimateConfiguration, variants: [AddABTestsVariant]) {
+        self.configuration = configuration
+        self.variants = variants
+    }
+
+    public enum CodingKeys: String, CodingKey, CaseIterable {
+        case configuration
+        case variants
+    }
+
+    // Encodable protocol methods
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(self.configuration, forKey: .configuration)
+        try container.encode(self.variants, forKey: .variants)
+    }
+}
+
+extension EstimateABTestRequest: Equatable {
+    public static func ==(lhs: EstimateABTestRequest, rhs: EstimateABTestRequest) -> Bool {
+        lhs.configuration == rhs.configuration &&
+            lhs.variants == rhs.variants
+    }
+}
+
+extension EstimateABTestRequest: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.configuration.hashValue)
+        hasher.combine(self.variants.hashValue)
+    }
+}

Sources/Abtesting/Models/EstimateABTestResponse.swift

@@ -0,0 +1,54 @@
+// 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
+
+public struct EstimateABTestResponse: Codable, JSONEncodable {
+    /// Estimated number of days needed to reach the sample sizes required for detecting the configured effect. This
+    /// value is based on historical traffic.
+    public var durationDays: Int64?
+    /// Number of tracked searches needed to be able to detect the configured effect for the control variant.
+    public var controlSampleSize: Int64?
+    /// Number of tracked searches needed to be able to detect the configured effect for the experiment variant.
+    public var experimentSampleSize: Int64?
+
+    public init(durationDays: Int64? = nil, controlSampleSize: Int64? = nil, experimentSampleSize: Int64? = nil) {
+        self.durationDays = durationDays
+        self.controlSampleSize = controlSampleSize
+        self.experimentSampleSize = experimentSampleSize
+    }
+
+    public enum CodingKeys: String, CodingKey, CaseIterable {
+        case durationDays
+        case controlSampleSize
+        case experimentSampleSize
+    }
+
+    // Encodable protocol methods
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encodeIfPresent(self.durationDays, forKey: .durationDays)
+        try container.encodeIfPresent(self.controlSampleSize, forKey: .controlSampleSize)
+        try container.encodeIfPresent(self.experimentSampleSize, forKey: .experimentSampleSize)
+    }
+}
+
+extension EstimateABTestResponse: Equatable {
+    public static func ==(lhs: EstimateABTestResponse, rhs: EstimateABTestResponse) -> Bool {
+        lhs.durationDays == rhs.durationDays &&
+            lhs.controlSampleSize == rhs.controlSampleSize &&
+            lhs.experimentSampleSize == rhs.experimentSampleSize
+    }
+}
+
+extension EstimateABTestResponse: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.durationDays?.hashValue)
+        hasher.combine(self.controlSampleSize?.hashValue)
+        hasher.combine(self.experimentSampleSize?.hashValue)
+    }
+}

Sources/Abtesting/Models/EstimateConfiguration.swift

@@ -0,0 +1,55 @@
+// 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
+
+/// A/B test configuration for estimating the sample size and duration using minimum detectable effect.
+public struct EstimateConfiguration: Codable, JSONEncodable {
+    public var outliers: Outliers?
+    public var emptySearch: EmptySearch?
+    public var minimumDetectableEffect: MinimumDetectableEffect
+
+    public init(
+        outliers: Outliers? = nil,
+        emptySearch: EmptySearch? = nil,
+        minimumDetectableEffect: MinimumDetectableEffect
+    ) {
+        self.outliers = outliers
+        self.emptySearch = emptySearch
+        self.minimumDetectableEffect = minimumDetectableEffect
+    }
+
+    public enum CodingKeys: String, CodingKey, CaseIterable {
+        case outliers
+        case emptySearch
+        case minimumDetectableEffect
+    }
+
+    // Encodable protocol methods
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encodeIfPresent(self.outliers, forKey: .outliers)
+        try container.encodeIfPresent(self.emptySearch, forKey: .emptySearch)
+        try container.encode(self.minimumDetectableEffect, forKey: .minimumDetectableEffect)
+    }
+}
+
+extension EstimateConfiguration: Equatable {
+    public static func ==(lhs: EstimateConfiguration, rhs: EstimateConfiguration) -> Bool {
+        lhs.outliers == rhs.outliers &&
+            lhs.emptySearch == rhs.emptySearch &&
+            lhs.minimumDetectableEffect == rhs.minimumDetectableEffect
+    }
+}
+
+extension EstimateConfiguration: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(self.outliers?.hashValue)
+        hasher.combine(self.emptySearch?.hashValue)
+        hasher.combine(self.minimumDetectableEffect.hashValue)
+    }
+}

Sources/Abtesting/Models/MinimumDetectableEffect.swift

@@ -10,38 +10,38 @@ import Foundation
 public struct MinimumDetectableEffect: Codable, JSONEncodable {
     /// Smallest difference in an observable metric between variants. For example, to detect a 10% difference between
     /// variants, set this value to 0.1.
-    public var size: Double?
-    public var effect: Effect?
+    public var size: Double
+    public var metric: EffectMetric
 
-    public init(size: Double? = nil, effect: Effect? = nil) {
+    public init(size: Double, metric: EffectMetric) {
         self.size = size
-        self.effect = effect
+        self.metric = metric
     }
 
     public enum CodingKeys: String, CodingKey, CaseIterable {
         case size
-        case effect
+        case metric
     }
 
     // Encodable protocol methods
 
     public func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
-        try container.encodeIfPresent(self.size, forKey: .size)
-        try container.encodeIfPresent(self.effect, forKey: .effect)
+        try container.encode(self.size, forKey: .size)
+        try container.encode(self.metric, forKey: .metric)
     }
 }
 
 extension MinimumDetectableEffect: Equatable {
     public static func ==(lhs: MinimumDetectableEffect, rhs: MinimumDetectableEffect) -> Bool {
         lhs.size == rhs.size &&
-            lhs.effect == rhs.effect
+            lhs.metric == rhs.metric
     }
 }
 
 extension MinimumDetectableEffect: Hashable {
     public func hash(into hasher: inout Hasher) {
-        hasher.combine(self.size?.hashValue)
-        hasher.combine(self.effect?.hashValue)
+        hasher.combine(self.size.hashValue)
+        hasher.combine(self.metric.hashValue)
     }
 }