// Autogenerated from Pigeon (v11.0.1), 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 isNullish(_ value: Any?) -> Bool {
  return value is NSNull || value == nil
}

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

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

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

enum MyBluetoothLowEnergyStateArgs: Int {
  case unknown = 0
  case unsupported = 1
  case unauthorized = 2
  case poweredOff = 3
  case poweredOn = 4
}

enum MyGattCharacteristicPropertyArgs: Int {
  case read = 0
  case write = 1
  case writeWithoutResponse = 2
  case notify = 3
  case indicate = 4
}

enum MyGattCharacteristicWriteTypeArgs: Int {
  case withResponse = 0
  case withoutResponse = 1
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyCentralManagerArgs {
  var stateNumberArgs: Int64

  static func fromList(_ list: [Any?]) -> MyCentralManagerArgs? {
    let stateNumberArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)

    return MyCentralManagerArgs(
      stateNumberArgs: stateNumberArgs
    )
  }
  func toList() -> [Any?] {
    return [
      stateNumberArgs,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyPeripheralManagerArgs {
  var stateNumberArgs: Int64

  static func fromList(_ list: [Any?]) -> MyPeripheralManagerArgs? {
    let stateNumberArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)

    return MyPeripheralManagerArgs(
      stateNumberArgs: stateNumberArgs
    )
  }
  func toList() -> [Any?] {
    return [
      stateNumberArgs,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyCentralArgs {
  var hashCodeArgs: Int64
  var uuidArgs: String

  static func fromList(_ list: [Any?]) -> MyCentralArgs? {
    let hashCodeArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let uuidArgs = list[1] as! String

    return MyCentralArgs(
      hashCodeArgs: hashCodeArgs,
      uuidArgs: uuidArgs
    )
  }
  func toList() -> [Any?] {
    return [
      hashCodeArgs,
      uuidArgs,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyPeripheralArgs {
  var hashCodeArgs: Int64
  var uuidArgs: String

  static func fromList(_ list: [Any?]) -> MyPeripheralArgs? {
    let hashCodeArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let uuidArgs = list[1] as! String

    return MyPeripheralArgs(
      hashCodeArgs: hashCodeArgs,
      uuidArgs: uuidArgs
    )
  }
  func toList() -> [Any?] {
    return [
      hashCodeArgs,
      uuidArgs,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyAdvertiseDataArgs {
  var nameArgs: String? = nil
  var serviceUUIDsArgs: [String?]
  var serviceDataArgs: [String?: FlutterStandardTypedData?]
  var manufacturerSpecificDataArgs: MyManufacturerSpecificDataArgs? = nil

  static func fromList(_ list: [Any?]) -> MyAdvertiseDataArgs? {
    let nameArgs: String? = nilOrValue(list[0])
    let serviceUUIDsArgs = list[1] as! [String?]
    let serviceDataArgs = list[2] as! [String?: FlutterStandardTypedData?]
    var manufacturerSpecificDataArgs: MyManufacturerSpecificDataArgs? = nil
    if let manufacturerSpecificDataArgsList: [Any?] = nilOrValue(list[3]) {
      manufacturerSpecificDataArgs = MyManufacturerSpecificDataArgs.fromList(manufacturerSpecificDataArgsList)
    }

    return MyAdvertiseDataArgs(
      nameArgs: nameArgs,
      serviceUUIDsArgs: serviceUUIDsArgs,
      serviceDataArgs: serviceDataArgs,
      manufacturerSpecificDataArgs: manufacturerSpecificDataArgs
    )
  }
  func toList() -> [Any?] {
    return [
      nameArgs,
      serviceUUIDsArgs,
      serviceDataArgs,
      manufacturerSpecificDataArgs?.toList(),
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyManufacturerSpecificDataArgs {
  var idArgs: Int64
  var dataArgs: FlutterStandardTypedData

  static func fromList(_ list: [Any?]) -> MyManufacturerSpecificDataArgs? {
    let idArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let dataArgs = list[1] as! FlutterStandardTypedData

    return MyManufacturerSpecificDataArgs(
      idArgs: idArgs,
      dataArgs: dataArgs
    )
  }
  func toList() -> [Any?] {
    return [
      idArgs,
      dataArgs,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyGattServiceArgs {
  var hashCodeArgs: Int64
  var uuidArgs: String
  var characteristicsArgs: [MyGattCharacteristicArgs?]

  static func fromList(_ list: [Any?]) -> MyGattServiceArgs? {
    let hashCodeArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let uuidArgs = list[1] as! String
    let characteristicsArgs = list[2] as! [MyGattCharacteristicArgs?]

    return MyGattServiceArgs(
      hashCodeArgs: hashCodeArgs,
      uuidArgs: uuidArgs,
      characteristicsArgs: characteristicsArgs
    )
  }
  func toList() -> [Any?] {
    return [
      hashCodeArgs,
      uuidArgs,
      characteristicsArgs,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyGattCharacteristicArgs {
  var hashCodeArgs: Int64
  var uuidArgs: String
  var propertyNumbersArgs: [Int64?]
  var descriptorsArgs: [MyGattDescriptorArgs?]

  static func fromList(_ list: [Any?]) -> MyGattCharacteristicArgs? {
    let hashCodeArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let uuidArgs = list[1] as! String
    let propertyNumbersArgs = list[2] as! [Int64?]
    let descriptorsArgs = list[3] as! [MyGattDescriptorArgs?]

    return MyGattCharacteristicArgs(
      hashCodeArgs: hashCodeArgs,
      uuidArgs: uuidArgs,
      propertyNumbersArgs: propertyNumbersArgs,
      descriptorsArgs: descriptorsArgs
    )
  }
  func toList() -> [Any?] {
    return [
      hashCodeArgs,
      uuidArgs,
      propertyNumbersArgs,
      descriptorsArgs,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct MyGattDescriptorArgs {
  var hashCodeArgs: Int64
  var uuidArgs: String
  var valueArgs: FlutterStandardTypedData? = nil

  static func fromList(_ list: [Any?]) -> MyGattDescriptorArgs? {
    let hashCodeArgs = list[0] is Int64 ? list[0] as! Int64 : Int64(list[0] as! Int32)
    let uuidArgs = list[1] as! String
    let valueArgs: FlutterStandardTypedData? = nilOrValue(list[2])

    return MyGattDescriptorArgs(
      hashCodeArgs: hashCodeArgs,
      uuidArgs: uuidArgs,
      valueArgs: valueArgs
    )
  }
  func toList() -> [Any?] {
    return [
      hashCodeArgs,
      uuidArgs,
      valueArgs,
    ]
  }
}

private class MyCentralManagerHostApiCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
      case 128:
        return MyCentralManagerArgs.fromList(self.readValue() as! [Any?])
      case 129:
        return MyGattCharacteristicArgs.fromList(self.readValue() as! [Any?])
      case 130:
        return MyGattDescriptorArgs.fromList(self.readValue() as! [Any?])
      case 131:
        return MyGattServiceArgs.fromList(self.readValue() as! [Any?])
      default:
        return super.readValue(ofType: type)
    }
  }
}

private class MyCentralManagerHostApiCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? MyCentralManagerArgs {
      super.writeByte(128)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattCharacteristicArgs {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattDescriptorArgs {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattServiceArgs {
      super.writeByte(131)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

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

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

class MyCentralManagerHostApiCodec: FlutterStandardMessageCodec {
  static let shared = MyCentralManagerHostApiCodec(readerWriter: MyCentralManagerHostApiCodecReaderWriter())
}

/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
protocol MyCentralManagerHostApi {
  func setUp(completion: @escaping (Result<MyCentralManagerArgs, Error>) -> Void)
  func startDiscovery() throws
  func stopDiscovery() throws
  func connect(peripheralHashCodeArgs: Int64, completion: @escaping (Result<Void, Error>) -> Void)
  func disconnect(peripheralHashCodeArgs: Int64, completion: @escaping (Result<Void, Error>) -> Void)
  func getMaximumWriteLength(peripheralHashCodeArgs: Int64, typeNumberArgs: Int64) throws -> Int64
  func readRSSI(peripheralHashCodeArgs: Int64, completion: @escaping (Result<Int64, Error>) -> Void)
  func discoverGATT(peripheralHashCodeArgs: Int64, completion: @escaping (Result<[MyGattServiceArgs], Error>) -> Void)
  func readCharacteristic(peripheralHashCodeArgs: Int64, characteristicHashCodeArgs: Int64, completion: @escaping (Result<FlutterStandardTypedData, Error>) -> Void)
  func writeCharacteristic(peripheralHashCodeArgs: Int64, characteristicHashCodeArgs: Int64, valueArgs: FlutterStandardTypedData, typeNumberArgs: Int64, completion: @escaping (Result<Void, Error>) -> Void)
  func notifyCharacteristic(peripheralHashCodeArgs: Int64, characteristicHashCodeArgs: Int64, stateArgs: Bool, completion: @escaping (Result<Void, Error>) -> Void)
  func readDescriptor(peripheralHashCodeArgs: Int64, descriptorHashCodeArgs: Int64, completion: @escaping (Result<FlutterStandardTypedData, Error>) -> Void)
  func writeDescriptor(peripheralHashCodeArgs: Int64, descriptorHashCodeArgs: Int64, valueArgs: FlutterStandardTypedData, completion: @escaping (Result<Void, Error>) -> Void)
}

/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
class MyCentralManagerHostApiSetup {
  /// The codec used by MyCentralManagerHostApi.
  static var codec: FlutterStandardMessageCodec { MyCentralManagerHostApiCodec.shared }
  /// Sets up an instance of `MyCentralManagerHostApi` to handle messages through the `binaryMessenger`.
  static func setUp(binaryMessenger: FlutterBinaryMessenger, api: MyCentralManagerHostApi?) {
    let setUpChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.setUp", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setUpChannel.setMessageHandler { _, reply in
        api.setUp() { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      setUpChannel.setMessageHandler(nil)
    }
    let startDiscoveryChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.startDiscovery", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      startDiscoveryChannel.setMessageHandler { _, reply in
        do {
          try api.startDiscovery()
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      startDiscoveryChannel.setMessageHandler(nil)
    }
    let stopDiscoveryChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.stopDiscovery", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      stopDiscoveryChannel.setMessageHandler { _, reply in
        do {
          try api.stopDiscovery()
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      stopDiscoveryChannel.setMessageHandler(nil)
    }
    let connectChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.connect", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      connectChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        api.connect(peripheralHashCodeArgs: peripheralHashCodeArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      connectChannel.setMessageHandler(nil)
    }
    let disconnectChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.disconnect", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      disconnectChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        api.disconnect(peripheralHashCodeArgs: peripheralHashCodeArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      disconnectChannel.setMessageHandler(nil)
    }
    let getMaximumWriteLengthChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.getMaximumWriteLength", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      getMaximumWriteLengthChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let typeNumberArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        do {
          let result = try api.getMaximumWriteLength(peripheralHashCodeArgs: peripheralHashCodeArgsArg, typeNumberArgs: typeNumberArgsArg)
          reply(wrapResult(result))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      getMaximumWriteLengthChannel.setMessageHandler(nil)
    }
    let readRSSIChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.readRSSI", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      readRSSIChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        api.readRSSI(peripheralHashCodeArgs: peripheralHashCodeArgsArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      readRSSIChannel.setMessageHandler(nil)
    }
    let discoverGATTChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.discoverGATT", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      discoverGATTChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        api.discoverGATT(peripheralHashCodeArgs: peripheralHashCodeArgsArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      discoverGATTChannel.setMessageHandler(nil)
    }
    let readCharacteristicChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.readCharacteristic", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      readCharacteristicChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let characteristicHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        api.readCharacteristic(peripheralHashCodeArgs: peripheralHashCodeArgsArg, characteristicHashCodeArgs: characteristicHashCodeArgsArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      readCharacteristicChannel.setMessageHandler(nil)
    }
    let writeCharacteristicChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.writeCharacteristic", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      writeCharacteristicChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let characteristicHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        let valueArgsArg = args[2] as! FlutterStandardTypedData
        let typeNumberArgsArg = args[3] is Int64 ? args[3] as! Int64 : Int64(args[3] as! Int32)
        api.writeCharacteristic(peripheralHashCodeArgs: peripheralHashCodeArgsArg, characteristicHashCodeArgs: characteristicHashCodeArgsArg, valueArgs: valueArgsArg, typeNumberArgs: typeNumberArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      writeCharacteristicChannel.setMessageHandler(nil)
    }
    let notifyCharacteristicChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.notifyCharacteristic", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      notifyCharacteristicChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let characteristicHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        let stateArgsArg = args[2] as! Bool
        api.notifyCharacteristic(peripheralHashCodeArgs: peripheralHashCodeArgsArg, characteristicHashCodeArgs: characteristicHashCodeArgsArg, stateArgs: stateArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      notifyCharacteristicChannel.setMessageHandler(nil)
    }
    let readDescriptorChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.readDescriptor", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      readDescriptorChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let descriptorHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        api.readDescriptor(peripheralHashCodeArgs: peripheralHashCodeArgsArg, descriptorHashCodeArgs: descriptorHashCodeArgsArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      readDescriptorChannel.setMessageHandler(nil)
    }
    let writeDescriptorChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerHostApi.writeDescriptor", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      writeDescriptorChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let peripheralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let descriptorHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        let valueArgsArg = args[2] as! FlutterStandardTypedData
        api.writeDescriptor(peripheralHashCodeArgs: peripheralHashCodeArgsArg, descriptorHashCodeArgs: descriptorHashCodeArgsArg, valueArgs: valueArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      writeDescriptorChannel.setMessageHandler(nil)
    }
  }
}
private class MyCentralManagerFlutterApiCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
      case 128:
        return MyAdvertiseDataArgs.fromList(self.readValue() as! [Any?])
      case 129:
        return MyGattCharacteristicArgs.fromList(self.readValue() as! [Any?])
      case 130:
        return MyGattDescriptorArgs.fromList(self.readValue() as! [Any?])
      case 131:
        return MyManufacturerSpecificDataArgs.fromList(self.readValue() as! [Any?])
      case 132:
        return MyPeripheralArgs.fromList(self.readValue() as! [Any?])
      default:
        return super.readValue(ofType: type)
    }
  }
}

private class MyCentralManagerFlutterApiCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? MyAdvertiseDataArgs {
      super.writeByte(128)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattCharacteristicArgs {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattDescriptorArgs {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else if let value = value as? MyManufacturerSpecificDataArgs {
      super.writeByte(131)
      super.writeValue(value.toList())
    } else if let value = value as? MyPeripheralArgs {
      super.writeByte(132)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

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

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

class MyCentralManagerFlutterApiCodec: FlutterStandardMessageCodec {
  static let shared = MyCentralManagerFlutterApiCodec(readerWriter: MyCentralManagerFlutterApiCodecReaderWriter())
}

/// Generated class from Pigeon that represents Flutter messages that can be called from Swift.
class MyCentralManagerFlutterApi {
  private let binaryMessenger: FlutterBinaryMessenger
  init(binaryMessenger: FlutterBinaryMessenger){
    self.binaryMessenger = binaryMessenger
  }
  var codec: FlutterStandardMessageCodec {
    return MyCentralManagerFlutterApiCodec.shared
  }
  func onStateChanged(stateNumberArgs stateNumberArgsArg: Int64, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerFlutterApi.onStateChanged", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([stateNumberArgsArg] as [Any?]) { _ in
      completion()
    }
  }
  func onDiscovered(peripheralArgs peripheralArgsArg: MyPeripheralArgs, rssiArgs rssiArgsArg: Int64, advertiseDataArgs advertiseDataArgsArg: MyAdvertiseDataArgs, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerFlutterApi.onDiscovered", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([peripheralArgsArg, rssiArgsArg, advertiseDataArgsArg] as [Any?]) { _ in
      completion()
    }
  }
  func onPeripheralStateChanged(peripheralArgs peripheralArgsArg: MyPeripheralArgs, stateArgs stateArgsArg: Bool, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerFlutterApi.onPeripheralStateChanged", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([peripheralArgsArg, stateArgsArg] as [Any?]) { _ in
      completion()
    }
  }
  func onCharacteristicValueChanged(characteristicArgs characteristicArgsArg: MyGattCharacteristicArgs, valueArgs valueArgsArg: FlutterStandardTypedData, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyCentralManagerFlutterApi.onCharacteristicValueChanged", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([characteristicArgsArg, valueArgsArg] as [Any?]) { _ in
      completion()
    }
  }
}
private class MyPeripheralManagerHostApiCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
      case 128:
        return MyAdvertiseDataArgs.fromList(self.readValue() as! [Any?])
      case 129:
        return MyGattCharacteristicArgs.fromList(self.readValue() as! [Any?])
      case 130:
        return MyGattDescriptorArgs.fromList(self.readValue() as! [Any?])
      case 131:
        return MyGattServiceArgs.fromList(self.readValue() as! [Any?])
      case 132:
        return MyManufacturerSpecificDataArgs.fromList(self.readValue() as! [Any?])
      case 133:
        return MyPeripheralManagerArgs.fromList(self.readValue() as! [Any?])
      default:
        return super.readValue(ofType: type)
    }
  }
}

private class MyPeripheralManagerHostApiCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? MyAdvertiseDataArgs {
      super.writeByte(128)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattCharacteristicArgs {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattDescriptorArgs {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattServiceArgs {
      super.writeByte(131)
      super.writeValue(value.toList())
    } else if let value = value as? MyManufacturerSpecificDataArgs {
      super.writeByte(132)
      super.writeValue(value.toList())
    } else if let value = value as? MyPeripheralManagerArgs {
      super.writeByte(133)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

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

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

class MyPeripheralManagerHostApiCodec: FlutterStandardMessageCodec {
  static let shared = MyPeripheralManagerHostApiCodec(readerWriter: MyPeripheralManagerHostApiCodecReaderWriter())
}

/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
protocol MyPeripheralManagerHostApi {
  func setUp(completion: @escaping (Result<MyPeripheralManagerArgs, Error>) -> Void)
  func addService(serviceArgs: MyGattServiceArgs, completion: @escaping (Result<Void, Error>) -> Void)
  func removeService(serviceHashCodeArgs: Int64) throws
  func clearServices() throws
  func startAdvertising(advertiseDataArgs: MyAdvertiseDataArgs, completion: @escaping (Result<Void, Error>) -> Void)
  func stopAdvertising() throws
  func getMaximumWriteLength(centralHashCodeArgs: Int64) throws -> Int64
  func sendReadCharacteristicReply(centralHashCodeArgs: Int64, characteristicHashCodeArgs: Int64, idArgs: Int64, offsetArgs: Int64, statusArgs: Bool, valueArgs: FlutterStandardTypedData) throws
  func sendWriteCharacteristicReply(centralHashCodeArgs: Int64, characteristicHashCodeArgs: Int64, idArgs: Int64, offsetArgs: Int64, statusArgs: Bool) throws
  func notifyCharacteristicValueChanged(centralHashCodeArgs: Int64, characteristicHashCodeArgs: Int64, valueArgs: FlutterStandardTypedData, completion: @escaping (Result<Void, Error>) -> Void)
}

/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
class MyPeripheralManagerHostApiSetup {
  /// The codec used by MyPeripheralManagerHostApi.
  static var codec: FlutterStandardMessageCodec { MyPeripheralManagerHostApiCodec.shared }
  /// Sets up an instance of `MyPeripheralManagerHostApi` to handle messages through the `binaryMessenger`.
  static func setUp(binaryMessenger: FlutterBinaryMessenger, api: MyPeripheralManagerHostApi?) {
    let setUpChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.setUp", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setUpChannel.setMessageHandler { _, reply in
        api.setUp() { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      setUpChannel.setMessageHandler(nil)
    }
    let addServiceChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.addService", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      addServiceChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let serviceArgsArg = args[0] as! MyGattServiceArgs
        api.addService(serviceArgs: serviceArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      addServiceChannel.setMessageHandler(nil)
    }
    let removeServiceChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.removeService", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      removeServiceChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let serviceHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        do {
          try api.removeService(serviceHashCodeArgs: serviceHashCodeArgsArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      removeServiceChannel.setMessageHandler(nil)
    }
    let clearServicesChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.clearServices", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      clearServicesChannel.setMessageHandler { _, reply in
        do {
          try api.clearServices()
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      clearServicesChannel.setMessageHandler(nil)
    }
    let startAdvertisingChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.startAdvertising", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      startAdvertisingChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let advertiseDataArgsArg = args[0] as! MyAdvertiseDataArgs
        api.startAdvertising(advertiseDataArgs: advertiseDataArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      startAdvertisingChannel.setMessageHandler(nil)
    }
    let stopAdvertisingChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.stopAdvertising", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      stopAdvertisingChannel.setMessageHandler { _, reply in
        do {
          try api.stopAdvertising()
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      stopAdvertisingChannel.setMessageHandler(nil)
    }
    let getMaximumWriteLengthChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.getMaximumWriteLength", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      getMaximumWriteLengthChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let centralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        do {
          let result = try api.getMaximumWriteLength(centralHashCodeArgs: centralHashCodeArgsArg)
          reply(wrapResult(result))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      getMaximumWriteLengthChannel.setMessageHandler(nil)
    }
    let sendReadCharacteristicReplyChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.sendReadCharacteristicReply", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      sendReadCharacteristicReplyChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let centralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let characteristicHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        let idArgsArg = args[2] is Int64 ? args[2] as! Int64 : Int64(args[2] as! Int32)
        let offsetArgsArg = args[3] is Int64 ? args[3] as! Int64 : Int64(args[3] as! Int32)
        let statusArgsArg = args[4] as! Bool
        let valueArgsArg = args[5] as! FlutterStandardTypedData
        do {
          try api.sendReadCharacteristicReply(centralHashCodeArgs: centralHashCodeArgsArg, characteristicHashCodeArgs: characteristicHashCodeArgsArg, idArgs: idArgsArg, offsetArgs: offsetArgsArg, statusArgs: statusArgsArg, valueArgs: valueArgsArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      sendReadCharacteristicReplyChannel.setMessageHandler(nil)
    }
    let sendWriteCharacteristicReplyChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.sendWriteCharacteristicReply", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      sendWriteCharacteristicReplyChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let centralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let characteristicHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        let idArgsArg = args[2] is Int64 ? args[2] as! Int64 : Int64(args[2] as! Int32)
        let offsetArgsArg = args[3] is Int64 ? args[3] as! Int64 : Int64(args[3] as! Int32)
        let statusArgsArg = args[4] as! Bool
        do {
          try api.sendWriteCharacteristicReply(centralHashCodeArgs: centralHashCodeArgsArg, characteristicHashCodeArgs: characteristicHashCodeArgsArg, idArgs: idArgsArg, offsetArgs: offsetArgsArg, statusArgs: statusArgsArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      sendWriteCharacteristicReplyChannel.setMessageHandler(nil)
    }
    let notifyCharacteristicValueChangedChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerHostApi.notifyCharacteristicValueChanged", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      notifyCharacteristicValueChangedChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let centralHashCodeArgsArg = args[0] is Int64 ? args[0] as! Int64 : Int64(args[0] as! Int32)
        let characteristicHashCodeArgsArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        let valueArgsArg = args[2] as! FlutterStandardTypedData
        api.notifyCharacteristicValueChanged(centralHashCodeArgs: centralHashCodeArgsArg, characteristicHashCodeArgs: characteristicHashCodeArgsArg, valueArgs: valueArgsArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      notifyCharacteristicValueChangedChannel.setMessageHandler(nil)
    }
  }
}
private class MyPeripheralManagerFlutterApiCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
      case 128:
        return MyCentralArgs.fromList(self.readValue() as! [Any?])
      case 129:
        return MyGattCharacteristicArgs.fromList(self.readValue() as! [Any?])
      case 130:
        return MyGattDescriptorArgs.fromList(self.readValue() as! [Any?])
      default:
        return super.readValue(ofType: type)
    }
  }
}

private class MyPeripheralManagerFlutterApiCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? MyCentralArgs {
      super.writeByte(128)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattCharacteristicArgs {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? MyGattDescriptorArgs {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

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

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

class MyPeripheralManagerFlutterApiCodec: FlutterStandardMessageCodec {
  static let shared = MyPeripheralManagerFlutterApiCodec(readerWriter: MyPeripheralManagerFlutterApiCodecReaderWriter())
}

/// Generated class from Pigeon that represents Flutter messages that can be called from Swift.
class MyPeripheralManagerFlutterApi {
  private let binaryMessenger: FlutterBinaryMessenger
  init(binaryMessenger: FlutterBinaryMessenger){
    self.binaryMessenger = binaryMessenger
  }
  var codec: FlutterStandardMessageCodec {
    return MyPeripheralManagerFlutterApiCodec.shared
  }
  func onStateChanged(stateNumberArgs stateNumberArgsArg: Int64, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerFlutterApi.onStateChanged", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([stateNumberArgsArg] as [Any?]) { _ in
      completion()
    }
  }
  func onReadCharacteristicCommandReceived(centralArgs centralArgsArg: MyCentralArgs, characteristicArgs characteristicArgsArg: MyGattCharacteristicArgs, idArgs idArgsArg: Int64, offsetArgs offsetArgsArg: Int64, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerFlutterApi.onReadCharacteristicCommandReceived", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([centralArgsArg, characteristicArgsArg, idArgsArg, offsetArgsArg] as [Any?]) { _ in
      completion()
    }
  }
  func onWriteCharacteristicCommandReceived(centralArgs centralArgsArg: MyCentralArgs, characteristicArgs characteristicArgsArg: MyGattCharacteristicArgs, idArgs idArgsArg: Int64, offsetArgs offsetArgsArg: Int64, valueArgs valueArgsArg: FlutterStandardTypedData, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerFlutterApi.onWriteCharacteristicCommandReceived", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([centralArgsArg, characteristicArgsArg, idArgsArg, offsetArgsArg, valueArgsArg] as [Any?]) { _ in
      completion()
    }
  }
  func onNotifyCharacteristicCommandReceived(centralArgs centralArgsArg: MyCentralArgs, characteristicArgs characteristicArgsArg: MyGattCharacteristicArgs, stateArgs stateArgsArg: Bool, completion: @escaping () -> Void) {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.bluetooth_low_energy_darwin.MyPeripheralManagerFlutterApi.onNotifyCharacteristicCommandReceived", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([centralArgsArg, characteristicArgsArg, stateArgsArg] as [Any?]) { _ in
      completion()
    }
  }
}