divkit/client/ios/DivKit/generated_sources/DivActionSubmit.swift

// Generated code. Do not modify.

import Foundation
import Serialization
import VGSL

public final class DivActionSubmit: Sendable {
  public final class Request: Sendable {
    @frozen
    public enum Method: String, CaseIterable, Sendable {
      case get = "get"
      case post = "post"
      case put = "put"
      case patch = "patch"
      case delete = "delete"
      case head = "head"
      case options = "options"
    }

    public final class Header: Sendable {
      public let name: Expression<String>
      public let value: Expression<String>

      public func resolveName(_ resolver: ExpressionResolver) -> String? {
        resolver.resolveString(name)
      }

      public func resolveValue(_ resolver: ExpressionResolver) -> String? {
        resolver.resolveString(value)
      }

      public convenience init(dictionary: [String: Any], context: ParsingContext) throws {
        self.init(
          name: try dictionary.getExpressionField("name", context: context),
          value: try dictionary.getExpressionField("value", context: context)
        )
      }

      init(
        name: Expression<String>,
        value: Expression<String>
      ) {
        self.name = name
        self.value = value
      }
    }

    public let headers: [Header]?
    public let method: Expression<Method> // default value: post
    public let url: Expression<URL>

    public func resolveMethod(_ resolver: ExpressionResolver) -> Method {
      resolver.resolveEnum(method) ?? Method.post
    }

    public func resolveUrl(_ resolver: ExpressionResolver) -> URL? {
      resolver.resolveUrl(url)
    }

    public convenience init(dictionary: [String: Any], context: ParsingContext) throws {
      self.init(
        headers: try dictionary.getOptionalArray("headers", transform: { (dict: [String: Any]) in try? DivActionSubmit.Request.Header(dictionary: dict, context: context) }),
        method: try dictionary.getOptionalExpressionField("method", context: context),
        url: try dictionary.getExpressionField("url", transform: URL.makeFromNonEncodedString, context: context)
      )
    }

    init(
      headers: [Header]? = nil,
      method: Expression<Method>? = nil,
      url: Expression<URL>
    ) {
      self.headers = headers
      self.method = method ?? .value(.post)
      self.url = url
    }
  }

  public static let type: String = "submit"
  public let containerId: Expression<String>
  public let onFailActions: [DivAction]?
  public let onSuccessActions: [DivAction]?
  public let request: Request

  public func resolveContainerId(_ resolver: ExpressionResolver) -> String? {
    resolver.resolveString(containerId)
  }

  public convenience init(dictionary: [String: Any], context: ParsingContext) throws {
    self.init(
      containerId: try dictionary.getExpressionField("container_id", context: context),
      onFailActions: try dictionary.getOptionalArray("on_fail_actions", transform: { (dict: [String: Any]) in try? DivAction(dictionary: dict, context: context) }),
      onSuccessActions: try dictionary.getOptionalArray("on_success_actions", transform: { (dict: [String: Any]) in try? DivAction(dictionary: dict, context: context) }),
      request: try dictionary.getField("request", transform: { (dict: [String: Any]) in try DivActionSubmit.Request(dictionary: dict, context: context) }, context: context)
    )
  }

  init(
    containerId: Expression<String>,
    onFailActions: [DivAction]? = nil,
    onSuccessActions: [DivAction]? = nil,
    request: Request
  ) {
    self.containerId = containerId
    self.onFailActions = onFailActions
    self.onSuccessActions = onSuccessActions
    self.request = request
  }
}

#if DEBUG
extension DivActionSubmit: Equatable {
  public static func ==(lhs: DivActionSubmit, rhs: DivActionSubmit) -> Bool {
    guard
      lhs.containerId == rhs.containerId,
      lhs.onFailActions == rhs.onFailActions,
      lhs.onSuccessActions == rhs.onSuccessActions
    else {
      return false
    }
    guard
      lhs.request == rhs.request
    else {
      return false
    }
    return true
  }
}
#endif

extension DivActionSubmit: Serializable {
  @_optimize(size)
  public func toDictionary() -> [String: ValidSerializationValue] {
    var result: [String: ValidSerializationValue] = [:]
    result["type"] = Self.type
    result["container_id"] = containerId.toValidSerializationValue()
    result["on_fail_actions"] = onFailActions?.map { $0.toDictionary() }
    result["on_success_actions"] = onSuccessActions?.map { $0.toDictionary() }
    result["request"] = request.toDictionary()
    return result
  }
}

#if DEBUG
extension DivActionSubmit.Request.Header: Equatable {
  public static func ==(lhs: DivActionSubmit.Request.Header, rhs: DivActionSubmit.Request.Header) -> Bool {
    guard
      lhs.name == rhs.name,
      lhs.value == rhs.value
    else {
      return false
    }
    return true
  }
}
#endif

#if DEBUG
extension DivActionSubmit.Request: Equatable {
  public static func ==(lhs: DivActionSubmit.Request, rhs: DivActionSubmit.Request) -> Bool {
    guard
      lhs.headers == rhs.headers,
      lhs.method == rhs.method,
      lhs.url == rhs.url
    else {
      return false
    }
    return true
  }
}
#endif

extension DivActionSubmit.Request.Header: Serializable {
  @_optimize(size)
  public func toDictionary() -> [String: ValidSerializationValue] {
    var result: [String: ValidSerializationValue] = [:]
    result["name"] = name.toValidSerializationValue()
    result["value"] = value.toValidSerializationValue()
    return result
  }
}

extension DivActionSubmit.Request: Serializable {
  @_optimize(size)
  public func toDictionary() -> [String: ValidSerializationValue] {
    var result: [String: ValidSerializationValue] = [:]
    result["headers"] = headers?.map { $0.toDictionary() }
    result["method"] = method.toValidSerializationValue()
    result["url"] = url.toValidSerializationValue()
    return result
  }
}