immich/mobile/ios/Runner/Core/Network.g.swift

// Autogenerated from Pigeon (v26.0.2), do not edit directly.
// See also: https://pub.dev/packages/pigeon

import Foundation

#if os(iOS)
  import Flutter
#elseif os(macOS)
  import FlutterMacOS
#else
  #error("Unsupported platform.")
#endif

private func wrapResult(_ result: Any?) -> [Any?] {
  return [result]
}

private func wrapError(_ error: Any) -> [Any?] {
  if let pigeonError = error as? PigeonError {
    return [
      pigeonError.code,
      pigeonError.message,
      pigeonError.details,
    ]
  }
  if let flutterError = error as? FlutterError {
    return [
      flutterError.code,
      flutterError.message,
      flutterError.details,
    ]
  }
  return [
    "\(error)",
    "\(type(of: error))",
    "Stacktrace: \(Thread.callStackSymbols)",
  ]
}

private func isNullish(_ value: Any?) -> Bool {
  return value is NSNull || value == nil
}

private func nilOrValue<T>(_ value: Any?) -> T? {
  if value is NSNull { return nil }
  return value as! T?
}

func deepEqualsNetwork(_ lhs: Any?, _ rhs: Any?) -> Bool {
  let cleanLhs = nilOrValue(lhs) as Any?
  let cleanRhs = nilOrValue(rhs) as Any?
  switch (cleanLhs, cleanRhs) {
  case (nil, nil):
    return true

  case (nil, _), (_, nil):
    return false

  case is (Void, Void):
    return true

  case let (cleanLhsHashable, cleanRhsHashable) as (AnyHashable, AnyHashable):
    return cleanLhsHashable == cleanRhsHashable

  case let (cleanLhsArray, cleanRhsArray) as ([Any?], [Any?]):
    guard cleanLhsArray.count == cleanRhsArray.count else { return false }
    for (index, element) in cleanLhsArray.enumerated() {
      if !deepEqualsNetwork(element, cleanRhsArray[index]) {
        return false
      }
    }
    return true

  case let (cleanLhsDictionary, cleanRhsDictionary) as ([AnyHashable: Any?], [AnyHashable: Any?]):
    guard cleanLhsDictionary.count == cleanRhsDictionary.count else { return false }
    for (key, cleanLhsValue) in cleanLhsDictionary {
      guard cleanRhsDictionary.index(forKey: key) != nil else { return false }
      if !deepEqualsNetwork(cleanLhsValue, cleanRhsDictionary[key]!) {
        return false
      }
    }
    return true

  default:
    // Any other type shouldn't be able to be used with pigeon. File an issue if you find this to be untrue.
    return false
  }
}

func deepHashNetwork(value: Any?, hasher: inout Hasher) {
  if let valueList = value as? [AnyHashable] {
     for item in valueList { deepHashNetwork(value: item, hasher: &hasher) }
     return
  }

  if let valueDict = value as? [AnyHashable: AnyHashable] {
    for key in valueDict.keys { 
      hasher.combine(key)
      deepHashNetwork(value: valueDict[key]!, hasher: &hasher)
    }
    return
  }

  if let hashableValue = value as? AnyHashable {
    hasher.combine(hashableValue.hashValue)
  }

  return hasher.combine(String(describing: value))
}

    

/// Generated class from Pigeon that represents data sent in messages.
struct ClientCertData: Hashable {
  var data: FlutterStandardTypedData
  var password: String


  // swift-format-ignore: AlwaysUseLowerCamelCase
  static func fromList(_ pigeonVar_list: [Any?]) -> ClientCertData? {
    let data = pigeonVar_list[0] as! FlutterStandardTypedData
    let password = pigeonVar_list[1] as! String

    return ClientCertData(
      data: data,
      password: password
    )
  }
  func toList() -> [Any?] {
    return [
      data,
      password,
    ]
  }
  static func == (lhs: ClientCertData, rhs: ClientCertData) -> Bool {
    return deepEqualsNetwork(lhs.toList(), rhs.toList())  }
  func hash(into hasher: inout Hasher) {
    deepHashNetwork(value: toList(), hasher: &hasher)
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct ClientCertPrompt: Hashable {
  var title: String
  var message: String
  var cancel: String
  var confirm: String


  // swift-format-ignore: AlwaysUseLowerCamelCase
  static func fromList(_ pigeonVar_list: [Any?]) -> ClientCertPrompt? {
    let title = pigeonVar_list[0] as! String
    let message = pigeonVar_list[1] as! String
    let cancel = pigeonVar_list[2] as! String
    let confirm = pigeonVar_list[3] as! String

    return ClientCertPrompt(
      title: title,
      message: message,
      cancel: cancel,
      confirm: confirm
    )
  }
  func toList() -> [Any?] {
    return [
      title,
      message,
      cancel,
      confirm,
    ]
  }
  static func == (lhs: ClientCertPrompt, rhs: ClientCertPrompt) -> Bool {
    return deepEqualsNetwork(lhs.toList(), rhs.toList())  }
  func hash(into hasher: inout Hasher) {
    deepHashNetwork(value: toList(), hasher: &hasher)
  }
}

private class NetworkPigeonCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
    case 129:
      return ClientCertData.fromList(self.readValue() as! [Any?])
    case 130:
      return ClientCertPrompt.fromList(self.readValue() as! [Any?])
    default:
      return super.readValue(ofType: type)
    }
  }
}

private class NetworkPigeonCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? ClientCertData {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? ClientCertPrompt {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

private class NetworkPigeonCodecReaderWriter: FlutterStandardReaderWriter {
  override func reader(with data: Data) -> FlutterStandardReader {
    return NetworkPigeonCodecReader(data: data)
  }

  override func writer(with data: NSMutableData) -> FlutterStandardWriter {
    return NetworkPigeonCodecWriter(data: data)
  }
}

class NetworkPigeonCodec: FlutterStandardMessageCodec, @unchecked Sendable {
  static let shared = NetworkPigeonCodec(readerWriter: NetworkPigeonCodecReaderWriter())
}


/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
protocol NetworkApi {
  func addCertificate(clientData: ClientCertData, completion: @escaping (Result<Void, Error>) -> Void)
  func selectCertificate(promptText: ClientCertPrompt, completion: @escaping (Result<Void, Error>) -> Void)
  func removeCertificate(completion: @escaping (Result<Void, Error>) -> Void)
  func hasCertificate() throws -> Bool
  func getClientPointer() throws -> Int64
  func setRequestHeaders(headers: [String: String], serverUrls: [String]) throws
}

/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
class NetworkApiSetup {
  static var codec: FlutterStandardMessageCodec { NetworkPigeonCodec.shared }
  /// Sets up an instance of `NetworkApi` to handle messages through the `binaryMessenger`.
  static func setUp(binaryMessenger: FlutterBinaryMessenger, api: NetworkApi?, messageChannelSuffix: String = "") {
    let channelSuffix = messageChannelSuffix.count > 0 ? ".\(messageChannelSuffix)" : ""
    let addCertificateChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NetworkApi.addCertificate\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      addCertificateChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let clientDataArg = args[0] as! ClientCertData
        api.addCertificate(clientData: clientDataArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      addCertificateChannel.setMessageHandler(nil)
    }
    let selectCertificateChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NetworkApi.selectCertificate\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      selectCertificateChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let promptTextArg = args[0] as! ClientCertPrompt
        api.selectCertificate(promptText: promptTextArg) { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      selectCertificateChannel.setMessageHandler(nil)
    }
    let removeCertificateChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NetworkApi.removeCertificate\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      removeCertificateChannel.setMessageHandler { _, reply in
        api.removeCertificate { result in
          switch result {
          case .success:
            reply(wrapResult(nil))
          case .failure(let error):
            reply(wrapError(error))
          }
        }
      }
    } else {
      removeCertificateChannel.setMessageHandler(nil)
    }
    let hasCertificateChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NetworkApi.hasCertificate\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      hasCertificateChannel.setMessageHandler { _, reply in
        do {
          let result = try api.hasCertificate()
          reply(wrapResult(result))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      hasCertificateChannel.setMessageHandler(nil)
    }
    let getClientPointerChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NetworkApi.getClientPointer\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      getClientPointerChannel.setMessageHandler { _, reply in
        do {
          let result = try api.getClientPointer()
          reply(wrapResult(result))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      getClientPointerChannel.setMessageHandler(nil)
    }
    let setRequestHeadersChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.immich_mobile.NetworkApi.setRequestHeaders\(channelSuffix)", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setRequestHeadersChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let headersArg = args[0] as! [String: String]
        let serverUrlsArg = args[1] as! [String]
        do {
          try api.setRequestHeaders(headers: headersArg, serverUrls: serverUrlsArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      setRequestHeadersChannel.setMessageHandler(nil)
    }
  }
}