OptimizelyUserContext for the Swift SDK

public class OptimizelyUserContext {
  public var userId: String
  public var attributes: [String: Any?] { get }
  
  public init(optimizely: OptimizelyClient,
              userId: String, 
              attributes: [String: Any?]? = nil)
  
  // Set an attribute for the user.
  public func setAttribute(key: String, value: Any?)    
  
  // Make a decision about which flag variation the user buckets into for the flag key.
  public func decide(key: String, 
                     options: [OptimizelyDecideOption]? = nil) -> OptimizelyDecision
  
  // Make decisions about which flag variations the user buckets into for flag keys.
  public func decide(keys: [String],                
                    options: [OptimizelyDecideOption]? = nil) -> [String: OptimizelyDecision]
  
  // Make decisions about which flag variations the user buckets into for all flags.
  public func decideAll(options: [OptimizelyDecideOption]? = nil) -> [String: OptimizelyDecision]
  
  // Track user event.
  public func trackEvent(eventKey: String, eventTags:  [String: Any]? = nil) throws
  
  // Asynchronously make a decision for the flag key (required for CMAB flags).
  public func decideAsync(key: String,
                          options: [OptimizelyDecideOption]? = nil,
                          completion: @escaping DecideCompletion)
  public func decideAsync(key: String,
                          options: [OptimizelyDecideOption]? = nil) async -> OptimizelyDecision
  
  // Asynchronously make decisions for the flag keys.
  public func decideAsync(keys: [String],
                          options: [OptimizelyDecideOption]? = nil,
                          completion: @escaping DecideForKeysCompletion)
  public func decideAsync(keys: [String],
                          options: [OptimizelyDecideOption]? = nil) async -> [String: OptimizelyDecision]
  
  // Asynchronously make decisions for all flags.
  public func decideAllAsync(options: [OptimizelyDecideOption]? = nil,
                             completion: @escaping DecideForKeysCompletion)
  public func decideAllAsync(options: [OptimizelyDecideOption]? = nil) async -> [String: OptimizelyDecision]
  
  // Sets a forced decision (variationKey) for a given decision context (flagKey and optional ruleKey).
  public func setForcedDecision(context: OptimizelyDecisionContext, 
                                decision: OptimizelyForcedDecision) -> Bool
  
  // Returns the forced decision (variationKey) for a given decision context (flagKey and optional ruleKey).
  public func getForcedDecision(context: OptimizelyDecisionContext) -> OptimizelyForcedDecision?

  // Removes the forced decision (variationKey) for a given decision context (flagKey and optional ruleKey).
  public func removeForcedDecision(context: OptimizelyDecisionContext) -> Bool

  // Removes all the forced decisions (variationKeys) for the user context.
  public func removeAllForcedDecisions() -> Bool

  //
  // The following methods require Real-Time Audiences for Feature Experimentation. 
  // See note following this code sample. 
  //

  // An array of audience segment names that the user is qualified for. 
  // The result of **fetchQualifiedSegments()** is saved here. 
  // Can be nil if not properly updated with fetchQualifiedSegments(). 
  // 
  //  You can read and write directly to the qualified segments array. 
  //  This lets you bypass the remote fetching process from ODP 
  //  or for utilizing your own fetching service.   
  public var qualifiedSegments: [String]? 

  // Fetch all qualified audience segments for the user context. 
  //
  // The segments fetched are saved in **qualifiedSegments** and can be accessed any time.
  // On failure, **qualifiedSegments** is nil and one of the following errors are returned:
  // - OptimizelyError.invalidSegmentIdentifier
  // - OptimizelyError.fetchSegmentsFailed(String)
  //
  // - Parameters:
  //   - options – (Optional) A set of options for fetching qualified segments.
  //   - completionHandler – A completion handler to be called with the fetch result. 
  //     On success, it passes a nil error and the fetched segments are saved in qualifiedSegments. 
  //     On failure, it passes a non-nil error.
  public func fetchQualifiedSegments(options: [OptimizelySegmentOption] = [],
                                     completionHandler: @escaping (OptimizelyError?) -> Void)

  // async form – throws the error instead of passing it to a completion handler.
  public func fetchQualifiedSegments(options: [OptimizelySegmentOption] = []) async throws

  // Synchronous form – blocks the calling thread until the fetch completes.
  public func fetchQualifiedSegments(options: [OptimizelySegmentOption] = []) throws


  //  Check if the user is qualified for the given segment. 
  // - Parameter segment – The segment name to check qualification for.
  // - Returns – True, if qualified.
  public func isQualifiedFor(segment: String) -> Bool
}

public typealias DecideCompletion = (OptimizelyDecision) -> Void
public typealias DecideForKeysCompletion = ([String: OptimizelyDecision]) -> Void

// OptimizelyDecisionContext
public struct OptimizelyDecisionContext {
  public let flagKey: String
  public let ruleKey: String?

  public init(flagKey: String, ruleKey: String? = nil)
}

// OptimizelyForcedDecision
public struct OptimizelyForcedDecision {
  public let variationKey: String

  public init(variationKey: String)
}